facter 4.0.44 → 4.0.50

data/lib/facter/resolvers/aix/utils/odm_query.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-# CuAt (Customized Attributes) non-default attribute values
-# CuDv (Customized Devices) the devices present on this machine
-# PdAt (Predefined Attributes) default values for all device attributes
-# PdDv (Predefined Devices) the list of all devices supported by this release of AIX
-
-module Facter
-  class ODMQuery
-    REPOS = %w[CuAt CuDv PdAt PdDv].freeze
-
-    def initialize
-      @query = ''
-      @conditions = []
-      @log = Facter::Log.new(self)
-    end
-
-    def equals(field, value)
-      @conditions << "#{field}='#{value}'"
-      self
-    end
-
-    def like(field, value)
-      @conditions << "#{field} like '#{value}'"
-      self
-    end
-
-    def execute
-      result = nil
-      REPOS.each do |repo|
-        break if result && !result.empty?
-
-        result = Facter::Core::Execution.execute("#{query} #{repo}", logger: @log)
-      end
-      result
-    end
-
-    def query
-      'odmget -q "' + @conditions.join(' AND ') + '"'
-    end
-  end
-end

data/lib/facter/resolvers/hostname_resolver.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    class Hostname < BaseResolver
-      @fact_list ||= {}
-      class << self
-        private
-
-        def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { retrieve_hostname(fact_name) }
-        end
-
-        def retrieve_hostname(fact_name)
-          output = Facter::Core::Execution.execute('hostname', logger: log)
-
-          # get domain
-          domain = read_domain(output)
-
-          # 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]}"
-          @fact_list[fact_name]
-        end
-
-        def read_domain(output)
-          if output =~ /.*?\.(.+$)/
-            domain = Regexp.last_match(1)
-          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
-          end
-          domain
-        end
-      end
-    end
-  end
-end

data/lib/facter/resolvers/networking_linux_resolver.rb

@@ -1,159 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    class NetworkingLinux < BaseResolver
-      @fact_list = {}
-      DIRS = ['/var/lib/dhclient/', '/var/lib/dhcp/', '/var/lib/dhcp3/', '/var/lib/NetworkManager/', '/var/db/'].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)
-          @fact_list ||= {}
-
-          retrieve_interface_info
-          retrieve_interfaces_mac_and_mtu
-          retrieve_default_interface
-          ::Resolvers::Utils::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
-          end
-        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}")
-
-          interfaces = {}
-
-          output.each_line do |ip_line|
-            ip_tokens = ip_line.split(' ')
-
-            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)
-          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]
-
-          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
-          end
-        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 = 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 = Util::FileHelper.safe_read("/var/lib/NetworkManager/#{lease_file}", nil)
-
-          return unless dhcp
-
-          dhcp = dhcp.match(/SERVER_ADDRESS=(.*)/)
-          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)
-          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[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]
-
-          @fact_list[:primary_interface] = default_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
-end

data/lib/facter/resolvers/puppet_version_resolver.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module Resolvers
-    class PuppetVersionResolver < BaseResolver
-      # :puppetversion
-
-      @fact_list ||= {}
-
-      class << self
-        private
-
-        def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { puppet_version(fact_name) }
-        end
-
-        def puppet_version(fact_name)
-          require 'puppet/version'
-          @fact_list[:puppetversion] = Puppet.version
-
-          @fact_list[fact_name]
-        end
-      end
-    end
-  end
-end

data/lib/facter/resolvers/utils/filesystem_helper.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  module FilesystemHelper
-    MOUNT_KEYS = %i[device filesystem path options
-                    available available_bytes size
-                    size_bytes used used_bytes capacity].freeze
-    class << self
-      def read_mountpoints
-        # TODO: this require must be replaced with "require 'sys/filesystem'" when a new release of
-        # djberg96/sys-filesystem gem is available
-        require_relative '../../patches/sysfilesystem/sys/statvfs.rb'
-        force_utf(Sys::Filesystem.mounts)
-      end
-
-      def read_mountpoint_stats(path)
-        require 'sys/filesystem'
-        Sys::Filesystem.stat(path)
-      end
-
-      def compute_capacity(used, total)
-        if used == total
-          '100%'
-        elsif used.positive?
-          "#{format('%<value>.2f', value: (used / total.to_f * 100))}%"
-        else
-          '0%'
-        end
-      end
-
-      private
-
-      def force_utf(mounts)
-        mounts.each do |mount|
-          mount.name.force_encoding('UTF-8')
-          mount.mount_type.force_encoding('UTF-8')
-          mount.mount_point.force_encoding('UTF-8')
-          mount.options.force_encoding('UTF-8')
-        end
-      end
-    end
-  end
-end

data/lib/facter/resolvers/utils/fingerprint.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  class FingerPrint
-    attr_accessor :sha1, :sha256
-    def initialize(sha1, sha256)
-      @sha1 = sha1
-      @sha256 = sha256
-    end
-  end
-end

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require 'ipaddr'
-
-module Resolvers
-  module Utils
-    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)
-          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

data/lib/facter/resolvers/utils/ssh.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Facter
-  class Ssh
-    attr_accessor :fingerprint, :type, :key, :name
-    def initialize(fingerprint, type, key, name)
-      @fingerprint = fingerprint
-      @type = type
-      @key = key
-      @name = name
-    end
-  end
-end

data/lib/facter/resolvers/utils/ssh_helper.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'base64'
-require 'digest/sha1'
-
-module Resolvers
-  module Utils
-    class SshHelper
-      class << self
-        SSH_NAME = { 'ssh-dss' => 'dsa', 'ecdsa-sha2-nistp256' => 'ecdsa',
-                     'ssh-ed25519' => 'ed25519', 'ssh-rsa' => 'rsa' }.freeze
-        SSH_FINGERPRINT = { 'rsa' => 1, 'dsa' => 2, 'ecdsa' => 3, 'ed25519' => 4 }.freeze
-
-        def create_ssh(key_type, key)
-          key_name = SSH_NAME[key_type]
-          decoded_key = Base64.decode64(key)
-          ssh_fp = SSH_FINGERPRINT[key_name]
-          sha1 = "SSHFP #{ssh_fp} 1 #{Digest::SHA1.new.update(decoded_key)}"
-          sha256 = "SSHFP #{ssh_fp} 2 #{Digest::SHA2.new.update(decoded_key)}"
-
-          fingerprint = Facter::FingerPrint.new(sha1, sha256)
-          Facter::Ssh.new(fingerprint, key_type, key, key_name)
-        end
-      end
-    end
-  end
-end