facter 4.0.46 → 4.0.47

data/lib/facter/resolvers/gce.rb

@@ -22,7 +22,7 @@ module Facter
         end
 
         def query_for_metadata
-          gce_data = extract_to_hash(Utils::Http.get_request(METADATA_URL, HEADERS))
+          gce_data = extract_to_hash(Facter::Util::Resolvers::Http.get_request(METADATA_URL, HEADERS))
           parse_instance(gce_data)
 
           gce_data.empty? ? nil : gce_data

data/lib/facter/resolvers/hostname_resolver.rb

@@ -3,41 +3,88 @@
 module Facter
   module Resolvers
     class Hostname < BaseResolver
+      # :fqdn
+      # :domain
+      # :hostname
+
       init_resolver
 
       class << self
         private
 
         def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { retrieve_hostname(fact_name) }
+          @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
         end
 
-        def retrieve_hostname(fact_name)
-          output = Facter::Core::Execution.execute('hostname', logger: log)
+        def retrieve_info(fact_name)
+          require 'socket'
+          output = Socket.gethostname
+          hostname, domain = retrieve_from_fqdn(output)
+
+          fqdn = retrieve_with_addrinfo(hostname) if hostname_and_no_domain?(hostname, domain)
+
+          _, domain = retrieve_from_fqdn(fqdn) if exists_and_valid_fqdn?(fqdn, hostname)
 
-          # get domain
-          domain = read_domain(output)
+          domain = read_domain unless exists_and_not_empty?(domain)
 
-          # get hostname
-          hostname = output =~ /(.*?)\./ ? Regexp.last_match(1) : output
-          @fact_list[:hostname] ||= hostname&.strip
-          @fact_list[:domain] ||= domain&.strip
-          @fact_list[:fqdn] ||= "#{@fact_list[:hostname]}.#{@fact_list[:domain]}"
+          construct_fact_list(hostname, domain, fqdn)
           @fact_list[fact_name]
         end
 
-        def read_domain(output)
-          if output =~ /.*?\.(.+$)/
-            domain = Regexp.last_match(1)
+        def retrieve_from_fqdn(output)
+          if output =~ /(.*?)\.(.+$)/
+            log.debug("Managed to read hostname: #{Regexp.last_match(1)} and domain: #{Regexp.last_match(2)}")
+            [Regexp.last_match(1), Regexp.last_match(2)]
           else
-            file_content = Util::FileHelper.safe_read('/etc/resolv.conf')
-            if file_content =~ /^search\s+(\S+)/
-              domain = Regexp.last_match(1)
-            elsif file_content =~ /^domain\s+(\S+)/
-              domain = Regexp.last_match(1)
-            end
+            log.debug("Only managed to read hostname: #{output}, no domain was found.")
+            [output, '']
+          end
+        end
+
+        def retrieve_with_addrinfo(host)
+          begin
+            name = Socket.getaddrinfo(host, 0, Socket::AF_UNSPEC, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME)[0]
+          rescue StandardError => e
+            @log.debug("Socket.getaddrinfo failed to retrieve fqdn for hostname #{host} with: #{e}")
+            return
           end
-          domain
+          return if name.nil? || name.empty? || host == name[2] || name[2] == name[3]
+
+          name[2]
+        end
+
+        def exists_and_valid_fqdn?(fqdn, hostname)
+          exists_and_not_empty?(fqdn) && fqdn.start_with?("#{hostname}.")
+        end
+
+        def hostname_and_no_domain?(hostname, domain)
+          domain.empty? && !hostname.empty?
+        end
+
+        def read_domain
+          file_content = Facter::Util::FileHelper.safe_read('/etc/resolv.conf')
+          if file_content =~ /^domain\s+(\S+)/
+            Regexp.last_match(1)
+          elsif file_content =~ /^search\s+(\S+)/
+            Regexp.last_match(1)
+          end
+        end
+
+        def construct_fqdn(host, domain, fqdn)
+          return fqdn if exists_and_not_empty?(fqdn)
+          return if host.nil? || host.empty?
+
+          exists_and_not_empty?(domain) ? "#{host}.#{domain}" : host
+        end
+
+        def construct_fact_list(hostname, domain, fqdn)
+          @fact_list[:hostname] = hostname
+          @fact_list[:domain] = domain
+          @fact_list[:fqdn] = construct_fqdn(@fact_list[:hostname], @fact_list[:domain], fqdn)
+        end
+
+        def exists_and_not_empty?(variable)
+          variable && !variable.empty?
         end
       end
     end

data/lib/facter/resolvers/linux/docker_uptime.rb

@@ -16,7 +16,7 @@ module Facter
           def detect_uptime(fact_name)
             days, hours, minutes, seconds = extract_uptime_from_docker
             total_seconds = convert_to_seconds(days, hours, minutes, seconds)
-            @fact_list = Utils::UptimeHelper.create_uptime_hash(total_seconds)
+            @fact_list =  Facter::Util::Resolvers::UptimeHelper.create_uptime_hash(total_seconds)
 
             @fact_list[fact_name]
           end

data/lib/facter/resolvers/linux/load_averages.rb

@@ -14,7 +14,7 @@ module Facter
           end
 
           def read_load_averages_file(fact_name)
-            output = Util::FileHelper.safe_read('/proc/loadavg')
+            output = Facter::Util::FileHelper.safe_read('/proc/loadavg')
             @fact_list[:load_averages] = {}.tap { |h| h['1m'], h['5m'], h['15m'], = output.split.map(&:to_f) }
 
             @fact_list[fact_name]

data/lib/facter/resolvers/load_averages.rb

@@ -13,10 +13,11 @@ module Facter
         end
 
         def read_load_averages(fact_name)
-          require_relative 'utils/ffi/load_averages'
+          require 'facter/util/resolvers/ffi/load_averages'
 
           log.debug('loading cpu load averages')
-          @fact_list[:load_averages] = %w[1m 5m 15m].zip(Utils::Ffi::LoadAverages.read_load_averages).to_h
+          @fact_list[:load_averages] = %w[1m 5m 15m].zip(Facter::Util::Resolvers::Ffi::LoadAverages
+            .read_load_averages).to_h
 
           @fact_list[fact_name]
         end

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

@@ -4,7 +4,7 @@ module Facter
   module Resolvers
     module Macosx
       class Mountpoints < BaseResolver
-        include Facter::FilesystemHelper
+        include Facter::Util::Resolvers::FilesystemHelper
         init_resolver
 
         class << self
@@ -17,7 +17,7 @@ module Facter
           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
@@ -35,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
@@ -47,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/system_profiler_resolver.rb

@@ -27,11 +27,11 @@ module Facter
           def retrieve_system_profiler(fact_name)
             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

@@ -16,7 +16,7 @@ module Facter
           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

@@ -3,7 +3,7 @@
 module Facter
   module Resolvers
     class Mountpoints < BaseResolver
-      include Facter::FilesystemHelper
+      include Facter::Util::Resolvers::FilesystemHelper
 
       init_resolver
 
@@ -17,7 +17,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]+)/)
           root = match&.captures&.first
 
@@ -45,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)
 
@@ -67,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_linux_resolver.rb

@@ -6,6 +6,15 @@ module Facter
       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
@@ -17,55 +26,188 @@ module Facter
         end
 
         def retrieve_network_info(fact_name)
-          retrieve_interface_info
-          retrieve_interfaces_mac_and_mtu
-          retrieve_default_interface
-          ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+          mtu_and_indexes = interfaces_mtu_and_index
+          retrieve_interface_info(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 retrieve_interfaces_mac_and_mtu
-          @fact_list[:interfaces].map do |name, info|
-            macaddress = Util::FileHelper.safe_read("/sys/class/net/#{name}/address", nil)
-            info[:mac] = macaddress.strip if macaddress && !macaddress.include?('00:00:00:00:00:00')
-            mtu = Util::FileHelper.safe_read("/sys/class/net/#{name}/mtu", nil)
-            info[:mtu] = mtu.strip.to_i if mtu
+        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')
+
+            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, mtu]
           end
+          mtu_and_indexes
         end
 
-        def retrieve_interface_info
-          log.debug('retrieve_interface_info')
-          output = Facter::Core::Execution.execute('ip -o address', logger: log)
-          log.debug("ip -o address result is:\n#{output}")
-
+        def retrieve_interface_info(mtu_and_indexes)
+          require 'socket'
           interfaces = {}
+          Socket.getifaddrs.each do |interface|
+            interfaces[interface.name] = {} if interfaces[interface.name].nil?
+
+            if interfaces[interface.name][:mac].nil?
+              mac = extract_mac_address(interface)
+              interfaces[interface.name][:mac] = mac if mac
+            end
 
-          output.each_line do |ip_line|
-            ip_tokens = ip_line.split(' ')
+            if interfaces[interface.name][:mtu].nil?
+              mtu = mtu_and_indexes.dig(interface.name, 1)
+              interfaces[interface.name][:mtu] = mtu unless mtu.nil?
+            end
 
-            log.debug("ip_tokens = #{ip_tokens}")
-            log.debug("interfaces = #{interfaces}")
-            fill_ip_v4_info!(ip_tokens, interfaces)
-            fill_io_v6_info!(ip_tokens, interfaces)
-            find_dhcp!(ip_tokens, interfaces)
+            if !interface.addr.nil? && !interface.netmask.nil?
+              begin
+                # ipv6 ips are retrieved as <ip>%<interface_name>
+                ip = interface.addr.ip_address.split('%').first if interface.addr.ip?
+                netmask = interface.netmask.ip_address
+                add_binding(interfaces, interface.name, ip, netmask, interface.addr.ipv4?)
+              rescue SocketError => e
+              end
+            end
+            find_dhcp!(interface.name, mtu_and_indexes, interfaces)
           end
 
           @fact_list[:interfaces] = interfaces
         end
 
-        def find_dhcp!(tokens, network_info)
-          interface_name = tokens[1]
-          return if !network_info[interface_name] || network_info[interface_name][:dhcp]
+        def extract_mac_address(interface)
+          mac = get_bonded_interface_mac(interface.name)
+          begin
+            if mac.nil?
+              if Socket.const_defined? :PF_LINK
+                mac = interface.addr&.getnameinfo&.first #sometimes it returns localhost, ip but mac also
+              elsif Socket.const_defined? :PF_PACKET
+                return if interface.addr.nil? || interface.addr.inspect_sockaddr.nil?
+
+                mac = interface.addr&.inspect_sockaddr[/hwaddr=([\h:]+)/, 1]
+              end
+            end
+          rescue StandardError => e
+            log.debug("Could not read mac, got #{e}")
+          end
+          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 get_bonded_interface_mac(interface_name)
+          master = get_bond_master(interface_name)
+          return unless master
+
+          output = Facter::Util::FileHelper.safe_read("/proc/net/bonding/#{master}", nil)
+          return unless output
+
+          right_block = false
+          output.each_line do |line|
+            if line.strip == "Slave Interface: #{interface_name}"
+              right_block = true
+            elsif line.include? 'Slave Interface'
+              right_block = false
+            end
+            return Regexp.last_match(1) if right_block && line =~ /Permanent HW addr: (\S*)/
+          end
+        end
+
+        def get_bond_master(interface_name)
+          content = Facter::Core::Execution.execute("ip link show #{interface_name}", logger: log)
+          master = content.match(/master (\S*) /)
+          return master[1] if master
+
+          nil
+        end
+
+        def add_binding(interfaces, name, ip, netmask, ip_v4_type)
+          binding = Facter::Util::Resolvers::Networking.build_binding(ip, netmask)
+          return if binding.nil?
+
+          log.debug("Adding to interface #{name}, binding:\n#{binding}")
+          binding_key = ip_v4_type == true ? :bindings : :bindings6
+          interfaces[name][binding_key] = [] if interfaces[name][binding_key].nil?
+          interfaces[name][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, 'ipv4')
+          routes6 = parse_routes(ipv6_output, 'ipv6')
+          [routes4, routes6]
+        end
+
+        def parse_routes(output, family)
+          routes = []
+          output.each_line do |line|
+            parts = line.split(' ').compact
+            next if parts.include?('linkdown')
+
+            route_type = parts[0]
+            parts.delete_at(0) if ROUTE_TYPES.include?(route_type)
+            next if family == 'ipv6' && !parts[0].include?(':')
+
+            route = construct_route(parts)
+            routes << route unless route[:ip].nil?
+          end
+          routes.uniq
+        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|
+            # TODO we should simplify this
+            if @fact_list[:interfaces].key?(route[:interface])
+              if @fact_list[:interfaces][route[:interface]][binding_key].nil?
+                @fact_list[:interfaces][route[:interface]][binding_key] = [{ address: route[:ip] }]
+              elsif @fact_list[:interfaces][route[:interface]][binding_key].none? { |binding| binding[:address] == route[:ip] }
+                @fact_list[:interfaces][route[:interface]][binding_key] << { address: route[:ip] }
+              end
+            end
+          end
+        end
 
-          index = tokens[0].delete(':')
-          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
+        def find_dhcp!(interface_name, interface_indexes, interfaces)
+          return if !interfaces[interface_name] || interfaces[interface_name][:dhcp]
+
+          log.debug("Get DHCP for interface #{interface_name}")
+          unless interface_indexes[interface_name].nil?
+            index = interface_indexes[interface_name][0]
+            file_content = Facter::Util::FileHelper.safe_read("/run/systemd/netif/leases/#{index}", nil)
+            dhcp = file_content.match(/SERVER_ADDRESS=(.*)/) if file_content
+            if dhcp
+              interfaces[interface_name][:dhcp] = dhcp[1]
+            else
+              alternate_dhcp = retrieve_from_other_directories(interface_name)
+              interfaces[interface_name][:dhcp] = alternate_dhcp if alternate_dhcp
+            end
           end
+          return unless interfaces[interface_name][:dhcp].nil?
+
+          output = Facter::Core::Execution.execute("dhcpcd -U #{interface_name}", logger: log)
+          result = output.match(/dhcp_server_identifier='(.*)'/)&.captures&.first
+          interfaces[interface_name][:dhcp] = result if result
         end
 
         def retrieve_from_other_directories(interface_name)
@@ -76,7 +218,7 @@ module Facter
             next if lease_files.empty?
 
             lease_files.select do |file|
-              content = Util::FileHelper.safe_read("#{dir}#{file}", nil)
+              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]+)/)
@@ -93,7 +235,7 @@ module Facter
           lease_file = files.find { |file| file =~ /internal.*#{interface_name}\.lease/ }
           return unless lease_file
 
-          dhcp = Util::FileHelper.safe_read("/var/lib/NetworkManager/#{lease_file}", nil)
+          dhcp = Facter::Util::FileHelper.safe_read("/var/lib/NetworkManager/#{lease_file}", nil)
 
           return unless dhcp
 
@@ -101,59 +243,15 @@ module Facter
           dhcp[1] if dhcp
         end
 
-        def fill_ip_v4_info!(ip_tokens, network_info)
-          log.debug('fill_ip_v4_info!')
-          return unless ip_tokens[2].casecmp('inet').zero?
-
-          interface_name, ip4_address, ip4_mask_length = retrieve_name_and_ip_info(ip_tokens)
-
-          log.debug("interface_name = #{interface_name}\n" \
-                      "ip4_address = #{ip4_address}\n" \
-                      "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
-        end
-
-        def retrieve_name_and_ip_info(tokens)
-          interface_name = tokens[1]
-          ip_info = tokens[4] =~ /peer/ ? tokens[5].split('/') : tokens[3].split('/')
-          ip_address = ip_info[0]
-          ip_mask_length = ip_info[1]
-
-          [interface_name, ip_address, ip_mask_length]
-        end
-
-        def fill_io_v6_info!(ip_tokens, network_info)
-          return unless ip_tokens[2].casecmp('inet6').zero?
-
-          interface_name, ip6_address, ip6_mask_length = retrieve_name_and_ip_info(ip_tokens)
-
-          binding = ::Resolvers::Utils::Networking.build_binding(ip6_address, ip6_mask_length)
-
-          build_network_info_structure!(network_info, interface_name, :bindings6)
-
-          network_info[interface_name][:scope6] ||= ip_tokens[5]
-          network_info[interface_name][:bindings6] << binding
-        end
-
-        def retrieve_default_interface
-          output = Facter::Core::Execution.execute('ip route get 1', logger: log)
-
-          ip_route_tokens = output.each_line.first.strip.split(' ')
-          default_interface = ip_route_tokens[4]
+        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] = default_interface
+          @fact_list[:primary_interface] = primary_interface
         end
 
-        def build_network_info_structure!(network_info, interface_name, binding)
-          network_info[interface_name] = {} unless network_info.dig(interface_name)
-          network_info[interface_name][binding] = [] unless network_info.dig(interface_name, binding)
-        end
       end
     end
   end