facter 4.0.51 → 4.0.52

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

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Networking < BaseResolver
+        init_resolver
+
+        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)
+            add_info_from_socket_reader
+            add_info_from_routing_table
+            retrieve_primary_interface
+            Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
+            @fact_list[fact_name]
+          end
+
+          def add_info_from_socket_reader
+            @fact_list[:interfaces] = Facter::Util::Linux::SocketParser.retrieve_interfaces(log)
+            mtu_and_indexes = interfaces_mtu_and_index
+
+            @fact_list[:interfaces].keys.each do |interface_name|
+              mtu(interface_name, mtu_and_indexes)
+              dhcp(interface_name, mtu_and_indexes)
+
+              @log.debug("Found interface #{interface_name} with #{@fact_list[:interfaces][interface_name]}")
+            end
+          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 mtu(interface_name, mtu_and_indexes)
+            mtu = mtu_and_indexes.dig(interface_name, :mtu)
+            @fact_list[:interfaces][interface_name][:mtu] = mtu unless mtu.nil?
+          end
+
+          def dhcp(interface_name, mtu_and_indexes)
+            dhcp = Facter::Util::Linux::Dhcp.dhcp(interface_name, mtu_and_indexes.dig(interface_name, :index), log)
+            @fact_list[:interfaces][interface_name][:dhcp] = dhcp unless dhcp.nil?
+          end
+
+          def add_info_from_routing_table
+            routes4, routes6 = Facter::Util::Linux::RoutingTable.read_routing_table(log)
+            compare_ips(routes4, :bindings)
+            compare_ips(routes6, :bindings6)
+          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 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
+end

data/lib/facter/resolvers/redhat_release.rb

@@ -6,6 +6,8 @@ module Facter
       # :name
       # :version
       # :codename
+      # :description
+      # :distributor_id
 
       init_resolver
 
@@ -26,29 +28,43 @@ module Facter
         end
 
         def build_fact_list(output)
+          @fact_list[:description] = output.strip
           output_strings = output.split('release')
           output_strings.map!(&:strip)
-          version_codename = output_strings[1].split(' ')
-
-          @fact_list[:name] = name(output_strings[0])
-          @fact_list[:version] = version_codename[0]&.strip
-
-          codename = version_codename[1]&.strip
-          @fact_list[:codename] = codename ? codename.gsub(/[()]/, '') : nil
 
+          @fact_list[:codename] = codename(output)
+          @fact_list[:distributor_id] = distributor_id(output_strings[0])
+          @fact_list[:name] = release_name(output_strings[0])
+          @fact_list[:version] = version(output_strings)
           @fact_list[:identifier] = identifier(@fact_list[:name])
         end
 
-        def name(name)
-          name.strip.split(' ')[0..1].join
+        def release_name(value)
+          value.split.reject { |el| el.casecmp('linux').zero? }[0..1].join
         end
 
-        def identifier(name)
-          identifier = name.strip.downcase
-          identifier = 'rhel' if @fact_list[:name].strip.casecmp('Red Hat Enterprise Linux')
+        def identifier(value)
+          identifier = value.downcase
+          identifier = 'rhel' if @fact_list[:name].casecmp('Red Hat Enterprise Linux')
 
           identifier
         end
+
+        def codename(value)
+          matched_data = value.match(/.*release.*(\(.*\)).*/)
+          return unless matched_data
+
+          codename = (matched_data[1] || '').gsub(/\(|\)/, '')
+          codename.empty? ? nil : codename
+        end
+
+        def version(value)
+          value[1].split.first
+        end
+
+        def distributor_id(value)
+          value.split.reject { |el| el.casecmp('linux').zero? }.join
+        end
       end
     end
   end

data/lib/facter/resolvers/solaris/ffi/functions.rb

@@ -6,7 +6,7 @@ module Facter
       module FFI
         module Ioctl
           extend ::FFI::Library
-          ffi_lib ::FFI::Library::LIBC, '/usr/lib/libsocket.so'
+          ffi_lib ::FFI::Library::LIBC, 'socket'
 
           attach_function :ioctl_base, :ioctl, %i[int int pointer], :int
           attach_function :open_socket, :socket, %i[int int int], :int

data/lib/facter/templates/man.erb

@@ -20,6 +20,14 @@ OPTIONS
 
 <% end -%>
 
+<% @Facter::Cli.commands.select { |_k, command_class| command_class.instance_of?(Thor::Command) }.each do |_, command| -%>
+  * `<%= command.usage %>`:
+
+    <%= command.description %>
+
+
+<% end -%>
+
 FILES
 -----
 <em>/etc/puppetlabs/facter/facter.conf</em>

data/lib/facter/util/linux/dhcp.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Linux
+      class Dhcp
+        class << self
+          DIRS = %w[/var/lib/dhclient/
+                    /var/lib/dhcp/
+                    /var/lib/dhcp3/
+                    /var/lib/NetworkManager/
+                    /var/db/].freeze
+
+          def dhcp(interface_name, interface_index, logger)
+            @log = logger
+            @log.debug("Get DHCP for interface #{interface_name}")
+
+            dhcp = search_systemd_netif_leases(interface_index, interface_name)
+            dhcp ||= search_dhclient_leases(interface_name)
+            dhcp ||= search_internal_leases(interface_name)
+            dhcp ||= search_with_dhcpcd_command(interface_name)
+            dhcp
+          end
+
+          private
+
+          def search_systemd_netif_leases(index, interface_name)
+            return if index.nil?
+
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from systemd/netif/leases")
+
+            file_content = Facter::Util::FileHelper.safe_read("/run/systemd/netif/leases/#{index}", nil)
+            dhcp = file_content.match(/SERVER_ADDRESS=(.*)/) if file_content
+            dhcp[1] if dhcp
+          end
+
+          def search_dhclient_leases(interface_name)
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from dhclient leases")
+
+            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 dhcp[1] if dhcp
+              end
+            end
+
+            nil
+          end
+
+          def search_internal_leases(interface_name)
+            return unless File.readable?('/var/lib/NetworkManager/')
+
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from NetworkManager leases")
+
+            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=(.*)/)
+            dhcp[1] if dhcp
+          end
+
+          def search_with_dhcpcd_command(interface_name)
+            @log.debug("Attempt to get DHCP for interface #{interface_name}, from dhcpcd command")
+
+            output = Facter::Core::Execution.execute("dhcpcd -U #{interface_name}", logger: @log)
+            dhcp = output.match(/dhcp_server_identifier='(.*)'/)
+            dhcp[1] if dhcp
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/linux/routing_table.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Linux
+      class RoutingTable
+        class << self
+          ROUTE_TYPES = %w[anycast
+                           unicast
+                           broadcast
+                           local
+                           nat
+                           unreachable
+                           prohibit
+                           blackhole
+                           throw].freeze
+
+          def read_routing_table(logger)
+            ipv4_output = Facter::Core::Execution.execute('ip route show', logger: logger)
+            ipv6_output = Facter::Core::Execution.execute('ip -6 route show', logger: logger)
+            routes4 = parse_routes(ipv4_output, true)
+            routes6 = parse_routes(ipv6_output, false)
+            [routes4, routes6]
+          end
+
+          private
+
+          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
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/linux/socket_parser.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Linux
+      class SocketParser
+        class << self
+          def retrieve_interfaces(logger)
+            require 'socket'
+            @interfaces = {}
+            @log = logger
+            Socket.getifaddrs.each do |ifaddr|
+              populate_interface_info(ifaddr)
+            end
+
+            @interfaces
+          end
+
+          private
+
+          def populate_interface_info(ifaddr)
+            interface_name = ifaddr.name
+            @interfaces[interface_name] = {} if @interfaces[interface_name].nil?
+
+            mac(ifaddr)
+            ip_info_of(ifaddr)
+          end
+
+          def mac(ifaddr)
+            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?
+
+              mac_from_sockaddr_of(ifaddr)
+            end
+          rescue StandardError => e
+            @log.debug("Could not read mac for interface #{ifaddr.name}, got #{e}")
+          end
+
+          def mac_from_sockaddr_of(ifaddr)
+            result = ifaddr.addr.inspect_sockaddr
+            result&.match(/hwaddr=([\h:]+)/)&.captures&.first
+          end
+
+          def ip_info_of(ifaddr)
+            return if ifaddr.addr.nil? || ifaddr.netmask.nil?
+
+            add_binding(ifaddr.name, ifaddr)
+          rescue StandardError => e
+            @log.debug("Could not read binding data, got #{e}")
+          end
+
+          def add_binding(interface_name, ifaddr)
+            ip, netmask, binding_key = binding_data(ifaddr)
+            binding = Facter::Util::Resolvers::Networking.build_binding(ip, netmask)
+            return if binding.nil?
+
+            @interfaces[interface_name][binding_key] = [] if @interfaces[interface_name][binding_key].nil?
+            @interfaces[interface_name][binding_key] << binding
+
+            @log.debug("Adding to interface #{interface_name}, binding:\n#{binding}")
+          end
+
+          def binding_data(ifaddr)
+            # ipv6 ips are retrieved as <ip>%<interface_name>
+            ip = ifaddr.addr.ip_address.split('%').first
+            netmask = ifaddr.netmask.ip_address
+            binding_key = ifaddr.addr.ipv4? ? :bindings : :bindings6
+
+            [ip, netmask, binding_key]
+          end
+        end
+      end
+    end
+  end
+end