openfact 5.0.0.rc0

data/lib/facter/util/facts/unit_converter.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      class UnitConverter
+        class << self
+          def bytes_to_mb(value_in_bytes)
+            return unless value_in_bytes
+
+            value_in_bytes = value_in_bytes.to_i
+
+            (value_in_bytes / (1024.0 * 1024.0))
+          end
+
+          def hertz_to_human_readable(speed)
+            speed = speed.to_i
+            return if !speed || speed.zero?
+
+            validated_speed, metric_prefix = determine_metric_prefix(speed)
+
+            "#{format('%<displayed_speed>.2f', displayed_speed: validated_speed.round(2))} #{metric_prefix}Hz"
+          end
+
+          def bytes_to_human_readable(bytes)
+            return unless bytes
+            return "#{bytes} bytes" if bytes < 1024
+
+            number, multiple = determine_exponent(bytes)
+
+            "#{pad_number(number)} #{multiple}"
+          end
+
+          private
+
+          def pad_number(number)
+            number = number.to_s
+            number << '0' if number.split('.').last.length == 1
+            number
+          end
+
+          def determine_exponent(bytes)
+            prefix = %w[KiB MiB GiB TiB PiB EiB]
+            exp = (Math.log2(bytes) / 10.0).floor
+            converted_number = (100.0 * (bytes / 1024.0**exp)).round / 100.0
+
+            if (converted_number - 1024.0).abs < Float::EPSILON
+              exp += 1
+              converted_number = 1.00
+            end
+            multiple = prefix[exp - 1] || 'bytes'
+
+            converted_number = bytes if multiple == 'bytes'
+            [converted_number, multiple]
+          end
+
+          def determine_metric_prefix(num)
+            metric_prefix = { 0 => '', 3 => 'k', 6 => 'M', 9 => 'G', 12 => 'T' }
+            power = Math.log10(num).floor
+            display_exponent = power - power % 3
+            coefficient = power.zero? ? num.to_f : num.fdiv(10**display_exponent)
+            [coefficient, metric_prefix[display_exponent]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/facts/uptime_parser.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Facter
+  module Util
+    module Facts
+      class UptimeParser
+        SECS_IN_A_DAY = 86_400
+        SECS_IN_AN_HOUR = 3_600
+        SECS_IN_A_MINUTE = 60
+
+        @log = Facter::Log.new(self)
+
+        class << self
+          def uptime_seconds_unix
+            uptime_proc_uptime || uptime_sysctl || uptime_executable
+          end
+
+          private
+
+          def uptime_proc_uptime
+            output = Facter::Core::Execution.execute("/bin/cat #{uptime_file}", logger: @log)
+
+            output.chomp.split(' ').first.to_i unless output.empty?
+          end
+
+          def uptime_sysctl
+            output = Facter::Core::Execution.execute("sysctl -n #{uptime_sysctl_variable}", logger: @log)
+
+            compute_uptime(Time.at(output.match(/\d+/)[0].to_i)) unless output.empty?
+          end
+
+          def uptime_executable
+            output = Facter::Core::Execution.execute(uptime_executable_cmd, logger: @log)
+
+            return unless output
+
+            up = 0
+            output_calculator_methods.find { |method| up = send(method, output) }
+            up || 0
+          end
+
+          def uptime_file
+            '/proc/uptime'
+          end
+
+          def uptime_sysctl_variable
+            'kern.boottime'
+          end
+
+          def uptime_executable_cmd
+            'uptime'
+          end
+
+          def output_calculator_methods
+            %i[
+              calculate_days_hours_minutes
+              calculate_days_hours
+              calculate_days_minutes
+              calculate_days
+              calculate_hours_minutes
+              calculate_hours
+              calculate_minutes
+            ]
+          end
+
+          def compute_uptime(time)
+            (Time.now - time).to_i
+          end
+
+          # Regexp handles Solaris, AIX, HP-UX, and Tru64.
+          # 'day(?:s|\(s\))?' says maybe 'day', 'days',
+          #   or 'day(s)', and don't set $2.
+          def calculate_days_hours_minutes(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,?\s+(\d+):-?(\d+)/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+              SECS_IN_AN_HOUR * Regexp.last_match(2).to_i +
+              SECS_IN_A_MINUTE * Regexp.last_match(3).to_i
+          end
+
+          def calculate_days_hours(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) hr(?:s|\(s\))?,/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+              SECS_IN_AN_HOUR * Regexp.last_match(2).to_i
+          end
+
+          def calculate_days_minutes(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,\s+(\d+) min(?:s|\(s\))?,/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i +
+              SECS_IN_A_MINUTE * Regexp.last_match(2).to_i
+          end
+
+          def calculate_days(output)
+            return unless output =~ /(\d+) day(?:s|\(s\))?,/
+
+            SECS_IN_A_DAY * Regexp.last_match(1).to_i
+          end
+
+          # must anchor to 'up' to avoid matching time of day
+          # at beginning of line. Certain versions of uptime on
+          # Solaris may insert a '-' into the minutes field.
+          def calculate_hours_minutes(output)
+            return unless output =~ /up\s+(\d+):-?(\d+),/
+
+            SECS_IN_AN_HOUR * Regexp.last_match(1).to_i +
+              SECS_IN_A_MINUTE * Regexp.last_match(2).to_i
+          end
+
+          def calculate_hours(output)
+            return unless output =~ /(\d+) hr(?:s|\(s\))?,/
+
+            SECS_IN_AN_HOUR * Regexp.last_match(1).to_i
+          end
+
+          def calculate_minutes(output)
+            return unless output =~ /(\d+) min(?:s|\(s\))?,/
+
+            SECS_IN_A_MINUTE * Regexp.last_match(1).to_i
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/facts/windows_release_finder.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      class WindowsReleaseFinder
+        class << self
+          def find_release(input)
+            version = input[:version]
+            return unless version
+
+            consumerrel = input[:consumerrel]
+            description = input[:description]
+            kernel_version = input[:kernel_version]
+
+            if /10.0/.match?(version)
+              check_version_10_11(consumerrel, kernel_version)
+            else
+              check_version_6(version, consumerrel) || check_version_5(version, consumerrel, description) || version
+            end
+          end
+
+          private
+
+          def check_version_10_11(consumerrel, kernel_version)
+            build_number = kernel_version[/([^.]*)$/].to_i
+
+            if consumerrel
+              if build_number >= 22_000
+                '11'
+              else
+                '10'
+              end
+            elsif build_number >= 26_100
+              '2025'
+            elsif build_number >= 20_348
+              '2022'
+            elsif build_number >= 17_623
+              '2019'
+            else
+              '2016'
+            end
+          end
+
+          def check_version_6(version, consumerrel)
+            hash = {}
+            hash['6.3'] = consumerrel ? '8.1' : '2012 R2'
+            hash['6.2'] = consumerrel ? '8' : '2012'
+            hash['6.1'] = consumerrel ? '7' : '2008 R2'
+            hash['6.0'] = consumerrel ? 'Vista' : '2008'
+            hash[version]
+          end
+
+          def check_version_5(version, consumerrel, description)
+            return unless /5.2/.match?(version)
+            return 'XP' if consumerrel
+
+            description == 'R2' ? '2003 R2' : '2003'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/file_helper.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    class FileHelper
+      @log = Log.new(self)
+
+      class << self
+        DEBUG_MESSAGE = 'File at: %s is not accessible.'
+
+        def safe_read(path, default_return = '')
+          return File.read(path, encoding: Encoding::UTF_8) if File.readable?(path)
+
+          log_failed_to_read(path)
+          default_return
+        end
+
+        # rubocop:disable Style/SpecialGlobalVars
+        def safe_readlines(path, default_return = [], sep = $/, chomp: false)
+          return File.readlines(path, sep, chomp: chomp, encoding: Encoding::UTF_8) if File.readable?(path)
+
+          log_failed_to_read(path)
+          default_return
+        end
+        # rubocop:enable Style/SpecialGlobalVars
+
+        # This previously acted as a helper method for versions of Ruby older
+        # than 2.5, before Dir.children was added. As it isn't a private
+        # method, we can't remove it entirely until the next major Facter
+        # release (presumably Facter 5).
+        def dir_children(path)
+          Dir.children(path)
+        end
+
+        private
+
+        def log_failed_to_read(path)
+          @log.debug(DEBUG_MESSAGE % path)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+# 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 /interface.*#{interface_name}/.match?(content)
+
+                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")
+
+            @dhcpcd_command ||= Facter::Core::Execution.which('dhcpcd')
+            return unless @dhcpcd_command
+
+            output = Facter::Core::Execution.execute("#{@dhcpcd_command} -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/if_inet6.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'ipaddr'
+
+module Facter
+  module Util
+    module Linux
+      class IfInet6
+        class << self
+          IFA_FLAGS = {
+            'temporary' => 0x01,
+            'noad' => 0x02,
+            'optimistic' => 0x04,
+            'dadfailed' => 0x08,
+            'homeaddress' => 0x10,
+            'deprecated' => 0x20,
+            'tentative' => 0x40,
+            'permanent' => 0x80
+            # /proc/net/if_inet6 only supports the old 8bit flags
+            # I have been unable to find a simple solution to accesses
+            # the full 32bit flags.  netlink is all I can could find but
+            # that will likely be ugly
+            # 'managetempaddr' => 0x100,
+            # 'noprefixroute' => 0x200,
+            # 'mcautojoin' => 0x400,
+            # 'stableprivacy' => 0x800
+          }.freeze
+
+          def read_flags
+            return read_flags_from_proc if File.exist?('/proc/net/if_inet6')
+
+            {}
+          end
+
+          private
+
+          def read_flags_from_proc
+            flags = init_flags
+            Facter::Util::FileHelper.safe_read('/proc/net/if_inet6', nil).each_line do |line|
+              iface = line.split
+              next unless iface.size == 6
+
+              ip = parse_ip(iface[0])
+              flags[iface[5]][ip] = parse_ifa_flags(iface[4])
+            end
+            flags
+          end
+
+          def init_flags
+            Hash.new { |h1, k1| h1[k1] = Hash.new { |h2, k2| h2[k2] = [] } }
+          end
+
+          def parse_ifa_flags(flag)
+            flag = flag.hex
+            flags = []
+            IFA_FLAGS.each_pair do |name, value|
+              next if (flag & value).zero?
+
+              flags << name
+            end
+            flags
+          end
+
+          def parse_ip(ip)
+            # The ip address in if_net6 is a long string wit no colons
+            ip = ip.scan(/(\h{4})/).join(':')
+            IPAddr.new(ip).to_s
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Linux
+      class Proc
+        class << self
+          def getenv_for_pid(pid, field)
+            path = "/proc/#{pid}/environ"
+            lines = Facter::Util::FileHelper.safe_readlines(path, [], "\0", chomp: true)
+            lines.each do |line|
+              key, value = line.split('=', 2)
+              return value if key == field
+            end
+            nil
+          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,130 @@
+# 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,19}([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 = get_ip_link_show_data(interface_name)
+            content&.match(/master (\S*) /)&.captures&.first
+          end
+
+          def get_ip_link_show_data(interface_name)
+            @ip_link_show_data ||= read_ip_link_show_data
+            @ip_link_show_data[interface_name]
+          end
+
+          def read_ip_link_show_data
+            ip_link_show_data = {}
+            output = Facter::Core::Execution.execute('ip -o link show', logger: @log)
+            output.each_line do |line|
+              interface_name = line.split(':')[1]&.strip if line
+              ip_link_show_data[interface_name] = line if interface_name
+            end
+            ip_link_show_data
+          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}")
+            nil
+          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