facter 4.0.47 → 4.0.48

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87e1b483df51f967d4e88c90f67ddfef304184d235d08746500c61619c56dee2
-  data.tar.gz: d573d4d221bc71e512c36a2f8218b0d70512ace56cb0eaa37dba3a9eee27bcde
+  metadata.gz: a97076330c5a6ac8a2d8ba6a5a36ecc3b8b3d5661d46057a444f0bafc1fe1e35
+  data.tar.gz: b84fcccd87ee9e7554e99342bf3722f383f23481480b9090e1cdba1ed26021ed
 SHA512:
-  metadata.gz: 49f5a8c11e45cdc6e9550e6fa50335700b8c43c048b46b1f091ea4b4a1f66588865a36c2ca1b447bea72c80a1548ca37d6f998eca4187047c6f2e95b2daf87d5
-  data.tar.gz: b6b21071a59dbfedc1499b6464e2556aa272f9fc99feb1674c6961a1a3a564570e9a7df127ad80140703ee320f73b1e41c82deec41dfb4160814544f1a0ae2d4
+  metadata.gz: beba9d7a66f00a6914558d54df18438a64e0e78f9d5109f5a5657f605480a26519a8c5a3b5b12e31c6c312a48c43066fadf302e433f6e57f129ba9214277e266
+  data.tar.gz: 73348a9dd6e2b68f50c7b73f543b0e90153b4753d2f7641ff078ee58860229af32c2f4a3871c25fc7da011308cb5ce20d2c6e455645b6c1e8ae2c59f9092b3b9

data/lib/facter.rb

@@ -381,7 +381,6 @@ module Facter
     # @api public
     def values(options, user_queries)
       init_cli_options(options, user_queries)
-      Options[:show_legacy] = true
       log_blocked_facts
       resolved_facts = Facter::FactManager.instance.resolve_facts(user_queries)
       resolved_facts.reject! { |fact| fact.type == :custom && fact.value.nil? }

data/lib/facter/config.rb

@@ -312,8 +312,7 @@ module Facter
           'operatingsystemrelease',
           'osfamily',
           'physicalprocessorcount',
-          'processor.*',
-          'processor*',
+          'processor[0-9]+.*',
           'processorcount',
           'productname',
           'rubyplatform',

data/lib/facter/custom_facts/util/fact.rb

@@ -43,6 +43,8 @@ module Facter
         @used_resolution_weight = 0
 
         @value = nil
+
+        @log = Facter::Log.new(self)
       end
 
       # Adds a new {Facter::Util::Resolution resolution}.  This requires a
@@ -201,11 +203,27 @@ module Facter
             break
           end
           @used_resolution_weight = resolve.weight
-          return value unless value.nil?
+          next if value.nil?
+
+          log_fact_path(resolve)
+
+          return value
         end
         nil
       end
 
+      def log_fact_path(resolve)
+        fact_type, resolved_from = if resolve.instance_of?(Facter::Core::Aggregate)
+                                     ['aggregate', resolve.instance_variable_get(:@aggregate).source_location[0]]
+                                   elsif resolve.fact_type == :external
+                                     ['external', resolve.file]
+                                   else
+                                     ['custom', resolve.last_evaluated]
+                                   end
+
+        @log.debug("#{fact_type} fact #{resolve.fact.name} got resolved from: #{resolved_from}")
+      end
+
       def announce_when_no_suitable_resolution(resolutions)
         return unless resolutions.empty?
 

data/lib/facter/custom_facts/util/resolution.rb

@@ -51,7 +51,7 @@ module Facter
       # @return [Facter::Util::Fact] Associated fact with this resolution.
       #
       # @api private
-      attr_reader :fact
+      attr_reader :fact, :last_evaluated, :file
 
       # Create a new resolution mechanism.
       #

data/lib/facter/facts/aix/disks.rb

@@ -4,7 +4,7 @@ module Facts
   module Aix
     class Disks
       FACT_NAME = 'disks'
-      ALIASES = %w[blockdevices blockdevice_.*_size'].freeze
+      ALIASES = %w[blockdevices blockdevice_.*_size].freeze
 
       def call_the_resolver
         facts = []

data/lib/facter/facts/aix/ssh.rb

@@ -16,7 +16,7 @@ module Facts
       end
 
       def resolver_data
-        Facter::Resolvers::SshResolver.resolve(:ssh)
+        Facter::Resolvers::Ssh.resolve(:ssh)
       end
 
       def create_ssh_fact(ssh)

data/lib/facter/facts/aix/sshalgorithmkey.rb

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
         facts
       end

data/lib/facter/facts/aix/sshfp_algorithm.rb

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
                                             "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)

data/lib/facter/facts/freebsd/ssh.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'ssh'
 
       def call_the_resolver
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         ssh_facts = {}
         result.each { |ssh| ssh_facts.merge!(create_ssh_fact(ssh)) }
         Facter::ResolvedFact.new(FACT_NAME, ssh_facts)

data/lib/facter/facts/freebsd/sshalgorithmkey.rb

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
         facts
       end

data/lib/facter/facts/freebsd/sshfp_algorithm.rb

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
                                             "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)

data/lib/facter/facts/linux/disks.rb

@@ -4,7 +4,7 @@ module Facts
   module Linux
     class Disks
       FACT_NAME = 'disks'
-      ALIASES = %w[blockdevices blockdevice_.*_model blockdevice_.*_size blockdevice_.*_vendor'].freeze
+      ALIASES = %w[blockdevices blockdevice_.*_model blockdevice_.*_size blockdevice_.*_vendor].freeze
 
       def call_the_resolver
         facts = []

data/lib/facter/facts/linux/os/family.rb

@@ -8,8 +8,10 @@ module Facts
         ALIASES = 'osfamily'
 
         def call_the_resolver
-          fact_value = Facter::Resolvers::OsRelease.resolve(:id_like)
-          fact_value ||= Facter::Resolvers::OsRelease.resolve(:id)
+          id = Facter::Resolvers::OsRelease.resolve(:id_like)
+          id ||= Facter::Resolvers::OsRelease.resolve(:id)
+
+          fact_value = Facter::Util::Facts.discover_family(id)
 
           [Facter::ResolvedFact.new(FACT_NAME, fact_value.capitalize),
            Facter::ResolvedFact.new(ALIASES, fact_value.capitalize, :legacy)]

data/lib/facter/facts/linux/ssh.rb

@@ -16,7 +16,7 @@ module Facts
       end
 
       def resolver_data
-        Facter::Resolvers::SshResolver.resolve(:ssh)
+        Facter::Resolvers::Ssh.resolve(:ssh)
       end
 
       def create_ssh_fact(ssh)

data/lib/facter/facts/linux/sshalgorithmkey.rb

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
         facts
       end

data/lib/facter/facts/linux/sshfp_algorithm.rb

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
                                             "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)

data/lib/facter/facts/macosx/ssh.rb

@@ -16,7 +16,7 @@ module Facts
       end
 
       def resolver_data
-        Facter::Resolvers::SshResolver.resolve(:ssh)
+        Facter::Resolvers::Ssh.resolve(:ssh)
       end
 
       def create_ssh_fact(ssh)

data/lib/facter/facts/macosx/sshalgorithmkey.rb

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
         facts
       end

data/lib/facter/facts/macosx/sshfp_algorithm.rb

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
                                             "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)

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

@@ -4,7 +4,7 @@ module Facts
   module Solaris
     class Disks
       FACT_NAME = 'disks'
-      ALIASES = %w[blockdevices blockdevice_.*_size blockdevice_.*_vendor'].freeze
+      ALIASES = %w[blockdevices blockdevice_.*_size blockdevice_.*_vendor].freeze
 
       def call_the_resolver
         facts = []

data/lib/facter/facts/solaris/ssh.rb

@@ -16,7 +16,7 @@ module Facts
       end
 
       def resolver_data
-        Facter::Resolvers::SshResolver.resolve(:ssh)
+        Facter::Resolvers::Ssh.resolve(:ssh)
       end
 
       def create_ssh_fact(ssh)

data/lib/facter/facts/solaris/sshalgorithmkey.rb

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
         facts
       end

data/lib/facter/facts/solaris/sshfp_algorithm.rb

@@ -8,7 +8,7 @@ module Facts
 
       def call_the_resolver
         facts = []
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result = Facter::Resolvers::Ssh.resolve(:ssh)
         result.each do |ssh|
           facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
                                             "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)

data/lib/facter/facts/windows/networking/fqdn.rb

@@ -12,7 +12,7 @@ module Facts
           hostname = Facter::Resolvers::Hostname.resolve(:hostname)
           return Facter::ResolvedFact.new(FACT_NAME, nil) if !hostname || hostname.empty?
 
-          fact_value = [hostname, domain].compact.join('.')
+          fact_value = domain && !domain.empty? ? [hostname, domain].compact.join('.') : hostname
 
           [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
         end

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

@@ -34,6 +34,7 @@ module Facter
     @timing = false
     @external_dir = []
     @custom_dir = []
+    @hocon = false
 
     class << self
       attr_reader :debug, :verbose, :log_level, :show_legacy,
@@ -42,7 +43,7 @@ module Facter
       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, :sequential, :timing
+                    :block_list, :color, :trace, :sequential, :timing, :hocon
 
       attr_writer :external_dir
 
@@ -171,6 +172,7 @@ module Facter
         @ruby = true
         @user_query = []
         @json = false
+        @hocon = false
         @cache = true
         @yaml = false
         @puppet = false

data/lib/facter/framework/detector/os_detector.rb

@@ -45,6 +45,7 @@ class OsDetector
     if hierarchy.empty?
       @log.debug("Could not detect hierarchy using os identifier: #{identifier} , trying with family")
 
+      # https://www.commandlinux.com/man-page/man5/os-release.5.html
       detect_family.to_s.split.each do |family|
         hierarchy = @os_hierarchy.construct_hierarchy(family)
         return hierarchy unless hierarchy.empty?

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)
+          @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