facter 4.0.47 → 4.0.52

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

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module Facts
-  module Linux
-    class Cloud
-      FACT_NAME = 'cloud'
-
-      def call_the_resolver
-        cloud_provider = Facter::Resolvers::Cloud.resolve(:cloud_provider)
-
-        Facter::ResolvedFact.new(FACT_NAME, cloud_provider)
-      end
-    end
-  end
-end

data/lib/facter/resolvers/cloud.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    class Cloud < BaseResolver
-      # cloud_provider
-
-      init_resolver
-
-      class << self
-        private
-
-        def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { detect_azure(fact_name) }
-        end
-
-        def detect_azure(fact_name)
-          search_dirs = %w[/var/lib/dhcp /var/lib/NetworkManager]
-          search_dirs.each do |path|
-            next if !File.readable?(path) || !File.directory?(path)
-
-            files = Dir.entries(path)
-            files.select! { |filename| filename =~ /^dhclient.*lease.*$/ }
-            files.each do |file|
-              path = File.join([path, file])
-              output = Facter::Util::FileHelper.safe_read(path)
-
-              if output.include?('option unknown-245') || output.include?('option 245')
-                @fact_list[:cloud_provider] = 'azure'
-                return @fact_list[fact_name]
-              end
-            end
-          end
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/facter/resolvers/networking_linux_resolver.rb

@@ -1,258 +0,0 @@
-# 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_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 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(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
-
-            if interfaces[interface.name][:mtu].nil?
-              mtu = mtu_and_indexes.dig(interface.name, 1)
-              interfaces[interface.name][:mtu] = mtu unless mtu.nil?
-            end
-
-            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 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
-
-        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)
-          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
-          return unless File.readable?('/var/lib/NetworkManager/')
-
-          search_internal_leases(interface_name)
-        end
-
-        def search_internal_leases(interface_name)
-          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 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

data/lib/facter/resolvers/redhat_release_resolver.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    class RedHatRelease < BaseResolver
-      # :name
-      # :version
-      # :codename
-
-      init_resolver
-
-      class << self
-        private
-
-        def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { read_redhat_release(fact_name) }
-        end
-
-        def read_redhat_release(fact_name)
-          output = Facter::Util::FileHelper.safe_read('/etc/redhat-release', nil)
-          return @fact_list[fact_name] = nil if output.nil?
-
-          build_fact_list(output)
-
-          @fact_list[fact_name]
-        end
-
-        def build_fact_list(output)
-          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[:identifier] = identifier(@fact_list[:name])
-        end
-
-        def name(name)
-          name.strip.split(' ')[0..1].join
-        end
-
-        def identifier(name)
-          identifier = name.strip.downcase
-          identifier = 'rhel' if @fact_list[:name].strip.casecmp('Red Hat Enterprise Linux')
-
-          identifier
-        end
-      end
-    end
-  end
-end

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

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'ipaddr'
-
-module Facter
-  module Util
-    module Resolvers
-      module Networking
-        class << self
-          # Creates a hash with IP, netmask and network. Works for IPV4 and IPV6
-          # @param [String] addr The IP address
-          # @param [Integer] mask_length Number of 1 bits the netmask has
-          #
-          # @return [Hash] Hash containing ip address, netmask and network
-          def build_binding(addr, mask_length)
-            return if !addr || !mask_length
-
-            ip = IPAddr.new(addr)
-            mask_helper = ip.ipv6? ? 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff' : '255.255.255.255'
-            mask = IPAddr.new(mask_helper).mask(mask_length)
-
-            { address: addr, netmask: mask.to_s, network: ip.mask(mask_length).to_s }
-          end
-
-          def expand_main_bindings(networking_facts)
-            primary = networking_facts[:primary_interface]
-            interfaces = networking_facts[:interfaces]
-
-            expand_interfaces(interfaces) unless interfaces.nil?
-            expand_primary_interface(networking_facts, primary) unless primary.nil? || interfaces.nil?
-          end
-
-          def get_scope(ip)
-            require 'socket'
-
-            scope6 = []
-            addrinfo = Addrinfo.new(['AF_INET6', 0, nil, ip], :INET6)
-
-            scope6 << 'compat,' if IPAddr.new(ip).ipv4_compat?
-            scope6 << if addrinfo.ipv6_linklocal?
-                        'link'
-                      elsif addrinfo.ipv6_sitelocal?
-                        'site'
-                      elsif addrinfo.ipv6_loopback?
-                        'host'
-                      else 'global'
-                      end
-            scope6.join
-          end
-
-          def find_valid_binding(bindings)
-            bindings.each do |binding|
-              return binding unless ignored_ip_address(binding[:address])
-            end
-            bindings.empty? ? nil : bindings.first
-          end
-
-          def ignored_ip_address(addr)
-            addr.empty? || addr.start_with?('127.', '169.254.') || addr.start_with?('fe80') || addr.eql?('::1')
-          end
-
-          private
-
-          def expand_interfaces(interfaces)
-            interfaces.each_value do |values|
-              expand_binding(values, values[:bindings]) if values[:bindings]
-              expand_binding(values, values[:bindings6], false) if values[:bindings6]
-            end
-          end
-
-          def expand_primary_interface(networking_facts, primary)
-            networking_facts[:interfaces][primary].each do |key, value|
-              networking_facts[key] = value unless %i[bindings bindings6].include?(key)
-            end
-          end
-
-          def expand_binding(values, bindings, ipv4_type = true)
-            binding = find_valid_binding(bindings)
-            ip_protocol_type = ipv4_type ? '' : '6'
-
-            values["ip#{ip_protocol_type}".to_sym] = binding[:address]
-            values["netmask#{ip_protocol_type}".to_sym] = binding[:netmask]
-            values["network#{ip_protocol_type}".to_sym] = binding[:network]
-            values[:scope6] = get_scope(binding[:address]) unless ipv4_type
-          end
-        end
-      end
-    end
-  end
-end