openfact 5.0.0.rc0

data/lib/facter/util/macosx/system_profile_executor.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Macosx
+      class SystemProfileExecutor
+        @log = Log.new(self)
+
+        class << self
+          def execute(category_name)
+            @log.debug "Executing command: system_profiler #{category_name}"
+            output = Facter::Core::Execution.execute(
+              "system_profiler #{category_name}", logger: @log
+            )&.force_encoding('UTF-8')
+
+            return unless output
+
+            system_profiler_hash = output_to_hash(output)
+
+            normalize_keys(system_profiler_hash)
+          end
+
+          private
+
+          def output_to_hash(output)
+            output.scan(/.*: .*$/).map { |e| e.strip.match(/(.*?): (.*)/).captures }.to_h
+          end
+
+          def normalize_keys(system_profiler_hash)
+            system_profiler_hash.transform_keys do |k|
+              k.downcase.tr(' ', '_').delete("\(\)").to_sym
+            end.to_h
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      module AwsToken
+        attr_reader :token
+
+        @log = Facter::Log.new(self)
+
+        class << self
+          AWS_API_TOKEN_URL = 'http://169.254.169.254/latest/api/token'
+
+          def get(lifetime = 100)
+            @expiry ||= Time.now
+
+            return @token if @token && @expiry > Time.now
+
+            @token = nil
+            @expiry = Time.now + lifetime
+
+            headers = {
+              'X-aws-ec2-metadata-token-ttl-seconds' => lifetime.to_s
+            }
+
+            @token = Facter::Util::Resolvers::Http.put_request(AWS_API_TOKEN_URL, headers)
+          end
+
+          def reset
+            @expiry = nil
+            @token = nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/resolvers/ffi/hostname.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Util
+    module Resolvers
+      module Ffi
+        class AddrInfo < ::FFI::Struct
+          layout  :ai_flags, :int,
+                  :ai_family, :int,
+                  :ai_socketype, :int,
+                  :ai_protocol, :int,
+                  :ai_addrlen, :uint,
+                  :ai_addr, :pointer,
+                  :ai_canonname, :string,
+                  :ai_next, :pointer
+        end
+
+        module Hostname
+          HOST_NAME_MAX = 64
+
+          extend ::FFI::Library
+          ffi_lib ::FFI::Library::LIBC
+
+          attach_function :getaddrinfo, %i[string string pointer pointer], :int
+          attach_function :gethostname, %i[pointer int], :int
+          attach_function :freeaddrinfo, [:pointer], :void
+
+          def self.getffihostname
+            raw_hostname = ::FFI::MemoryPointer.new(:char, HOST_NAME_MAX)
+
+            res = Hostname.gethostname(raw_hostname, HOST_NAME_MAX)
+            return unless res.zero?
+
+            raw_hostname.read_string
+          end
+
+          def self.getffiaddrinfo(hostname)
+            ret = FFI::MemoryPointer.new(:pointer)
+
+            hints = Facter::Util::Resolvers::Ffi::AddrInfo.new
+            hints[:ai_family] = Socket::AF_UNSPEC
+            hints[:ai_socketype] = Socket::SOCK_STREAM
+            hints[:ai_flags] = Socket::AI_CANONNAME
+
+            res = Hostname.getaddrinfo(hostname, '', hints.to_ptr, ret)
+            log = Log.new(self)
+            log.debug("FFI Getaddrinfo finished with exit status: #{res}")
+            log.debug("FFI Getaddrinfo returned an AddrInfo struct at address: #{ret}")
+            return unless res.zero?
+
+            return if ret == FFI::Pointer::NULL || ret.read_pointer == FFI::Pointer::NULL
+
+            begin
+              addr = Facter::Util::Resolvers::Ffi::AddrInfo.new(ret.read_pointer)
+              name = addr[:ai_canonname]
+              log.debug("FFI AddrInfo struct has the fqdn: #{name}")
+              return if !name || hostname == name
+
+              name
+            ensure
+              Hostname.freeaddrinfo(ret.read_pointer)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/resolvers/ffi/load_averages.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Util
+    module Resolvers
+      module Ffi
+        module LoadAverages
+          extend ::FFI::Library
+          ffi_lib ::FFI::Library::LIBC
+
+          attach_function :getloadavg, %i[pointer int], :int
+
+          def self.read_load_averages
+            raw_loadavg = ::FFI::MemoryPointer.new(:double, 3)
+
+            res = LoadAverages.getloadavg(raw_loadavg, 3)
+            return unless res == 3
+
+            raw_loadavg.read_array_of_double(res)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      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
+            require 'sys/filesystem'
+            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
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      FingerPrint = Struct.new(:sha1, :sha256)
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      module Http
+        @log = Facter::Log.new(self)
+
+        class << self
+          CONNECTION_TIMEOUT = 0.6
+          SESSION_TIMEOUT = 5
+
+          # Makes a GET HTTP request and returns its response.
+          #
+          # @param url [String] the address to which the request will be made.
+          # @param headers [Hash] the headers you need to add to your request.
+          #   Defaults to an empty hash.
+          # @param timeouts [Hash] Values for the session and connection
+          #   timeouts.
+          # @param proxy [Boolean] Whether to use proxy settings when calling
+          #   Net::HTTP.new. Defaults to true.
+          # @returns [String] the response body if the response code is 200.
+          #   If the response code is not 200, an empty string is returned.
+          # @example
+          #   get_request('https://example.com', { "Accept": 'application/json' }, { session: 2.4, connection: 5 })
+          def get_request(url, headers = {}, timeouts = {}, proxy = true)
+            make_request(url, headers, timeouts, 'GET', proxy)
+          end
+
+          # Makes a PUT HTTP request and returns its response
+          # @param (see #get_request)
+          # @return (see #get_request)
+          def put_request(url, headers = {}, timeouts = {}, proxy = true)
+            make_request(url, headers, timeouts, 'PUT', proxy)
+          end
+
+          private
+
+          def make_request(url, headers, timeouts, request_type, proxy)
+            require 'net/http'
+
+            uri = URI.parse(url)
+            http = http_obj(uri, timeouts, proxy)
+            request = request_obj(headers, uri, request_type)
+
+            # The Windows implementation of sockets does not respect net/http
+            # timeouts, so check if the target is reachable in a different way
+            if Gem.win_platform?
+              Socket.tcp(uri.host, uri.port, connect_timeout: timeouts[:connection] || CONNECTION_TIMEOUT)
+            end
+
+            # Make the request
+            response = http.request(request)
+            response.uri = url
+
+            successful_response?(response) ? response.body : ''
+          rescue StandardError => e
+            @log.debug("Trying to connect to #{url} but got: #{e.message}")
+            ''
+          end
+
+          def http_obj(parsed_url, timeouts, proxy)
+            # If get_request or put_request are called and set proxy to false,
+            # manually set Net::HTTP.new's p_addr (proxy address) positional
+            # argument to nil to override anywhere else a proxy may be set
+            # (e.g. the http_proxy environment variable).
+            http = if proxy
+                     Net::HTTP.new(parsed_url.host)
+                   else
+                     Net::HTTP.new(parsed_url.host, 80, nil)
+                   end
+            http.read_timeout = timeouts[:session] || SESSION_TIMEOUT
+            http.open_timeout = timeouts[:connection] || CONNECTION_TIMEOUT
+
+            http.set_debug_output($stderr) if Options[:http_debug]
+
+            http
+          end
+
+          def request_obj(headers, parsed_url, request_type)
+            Module.const_get("Net::HTTP::#{request_type.capitalize}").new(parsed_url.request_uri, headers)
+          end
+
+          def successful_response?(response)
+            success = response.code.to_i.equal?(200)
+
+            @log.debug("Request to #{response.uri} failed with error code #{response.code}") unless success
+
+            success
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      module Networking
+        module Dhcp
+          class << self
+            def get(interface_name, log = nil)
+              dhcpinfo_command = Facter::Core::Execution.which('dhcpinfo') || '/sbin/dhcpinfo'
+              result = Facter::Core::Execution.execute("#{dhcpinfo_command} -i #{interface_name} ServerID", logger: log)
+              result.chomp!
+
+              result.empty? ? nil : result
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# 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 = nil
+            scope = nil
+            if ip.ipv6?
+              scope = get_scope(addr)
+              mask_helper = 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'
+            else
+              mask_helper = '255.255.255.255'
+            end
+            mask = IPAddr.new(mask_helper).mask(mask_length)
+
+            result = { address: addr, netmask: mask.to_s, network: ip.mask(mask_length).to_s }
+            result[:scope6] = scope if scope
+            result
+          end
+
+          def expand_main_bindings(networking_facts)
+            primary = networking_facts[:primary_interface]
+            interfaces = networking_facts[:interfaces]
+
+            expand_interfaces(interfaces) unless interfaces.nil?
+            return if primary.nil? || interfaces.nil? || networking_facts.nil?
+
+            expand_primary_interface(networking_facts, primary)
+          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
+
+          IPV4_LINK_LOCAL_ADDR = IPAddr.new('169.254.0.0/16').freeze # RFC5735
+          IPV6_LINK_LOCAL_ADDR = IPAddr.new('fe80::/10').freeze # RFC4291
+          IPV6_UNIQUE_LOCAL_ADDR = IPAddr.new('fc00::/7').freeze # RFC4193
+
+          def ignored_ip_address(addr)
+            return true if addr.empty?
+
+            ip = IPAddr.new(addr)
+            return true if ip.loopback?
+
+            [
+              IPV4_LINK_LOCAL_ADDR,
+              IPV6_LINK_LOCAL_ADDR,
+              IPV6_UNIQUE_LOCAL_ADDR
+            ].each do |range|
+              return true if range.include?(ip)
+            end
+
+            false
+          end
+
+          def calculate_mask_length(netmask)
+            ipaddr = IPAddr.new(netmask)
+
+            ipaddr.to_i.to_s(2).count('1')
+          end
+
+          def format_mac_address(address)
+            address.split('.').map { |e| format('%<mac_address>02s', mac_address: e) }.join(':').tr(' ', '0')
+          end
+
+          private
+
+          def expand_interfaces(interfaces)
+            interfaces.each_value do |values|
+              expand_binding(values, values[:bindings]) if values[:bindings]
+              expand_binding(values, values[:bindings6], ipv4_type: 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

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      module Networking
+        module PrimaryInterface
+          @log ||= Log.new(self)
+
+          class << self
+            ROUTE_TABLE_MAPPING = {
+              'Iface' => 0,
+              'Destination' => 1,
+              'Gateway' => 2,
+              'Flags' => 3,
+              'RefCnt' => 4,
+              'Use' => 5,
+              'Metric' => 6,
+              'Mask' => 7,
+              'MTU' => 8,
+              'Window' => 9,
+              'IRTT' => 10
+            }.freeze
+
+            def read_from_route
+              return if Facter::Core::Execution.which('route').nil?
+
+              result = Facter::Core::Execution.execute('route -n get default', logger: @log)
+
+              result.match(/interface: (.+)/)&.captures&.first
+            end
+
+            def read_from_proc_route
+              content = Facter::Util::FileHelper.safe_read('/proc/net/route', '')
+
+              content.each_line.with_index do |line, index|
+                next if index.zero?
+
+                route = line.strip.split("\t")
+
+                return route[ROUTE_TABLE_MAPPING['Iface']] if valid_default_route?(route)
+              end
+
+              nil
+            end
+
+            def read_from_ip_route
+              return if Facter::Core::Execution.which('ip').nil?
+
+              output = Facter::Core::Execution.execute('ip route show default', logger: @log)
+              primary_interface = nil
+              output.each_line do |line|
+                primary_interface = line.strip.split(' ')[4] if line.start_with?('default')
+              end
+
+              primary_interface
+            end
+
+            def find_in_interfaces(interfaces)
+              return if interfaces.nil?
+
+              interfaces.each do |iface_name, interface|
+                interface[:bindings]&.each do |binding|
+                  return iface_name unless Facter::Util::Resolvers::Networking.ignored_ip_address(binding[:address])
+                end
+
+                next unless interface[:bindings6]
+
+                interface[:bindings6].each do |binding|
+                  return iface_name unless Facter::Util::Resolvers::Networking.ignored_ip_address(binding[:address])
+                end
+              end
+
+              nil
+            end
+
+            private
+
+            def valid_default_route?(route)
+              route.count > 7 &&
+                route[ROUTE_TABLE_MAPPING['Destination']] == '00000000' &&
+                route[ROUTE_TABLE_MAPPING['Mask']] == '00000000' &&
+                route[ROUTE_TABLE_MAPPING['Iface']] != '*' # `*` represents blackhole and not a valid interface
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      Ssh = Struct.new(:fingerprint, :type, :key, :name)
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'digest/sha1'
+
+module Facter
+  module Util
+    module Resolvers
+      class SshHelper
+        class << self
+          SSH_NAME = { 'ssh-dss' => 'dsa', 'ecdsa-sha2-nistp256' => 'ecdsa',
+                       'ecdsa-sha2-nistp384' => 'ecdsa', 'ecdsa-sha2-nistp521' => '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]
+            return unless key_name
+
+            # decode64 ignores non-base64 characters including newlines
+            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::Util::Resolvers::FingerPrint.new(sha1, sha256)
+            Facter::Util::Resolvers::Ssh.new(fingerprint, key_type, key, key_name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Resolvers
+      module UptimeHelper
+        class << self
+          def create_uptime_hash(seconds)
+            results = {}
+            minutes = (seconds / 60) % 60
+
+            results[:seconds] = seconds
+            results[:hours]   = seconds / (60 * 60)
+            results[:days]    = results[:hours] / 24
+            results[:uptime]  = build_uptime_text(results[:days], results[:hours], minutes)
+
+            results
+          end
+
+          def build_uptime_text(days, hours, minutes)
+            case days
+            when 0 then "#{hours}:#{format('%<minutes>02d', minutes: minutes)} hours"
+            when 1 then '1 day'
+            else
+              "#{days} days"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/util/utils.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Facter
+  module Utils
+    # Sort nested hash.
+    def self.sort_hash_by_key(hash, recursive: true, &block)
+      hash.keys.sort(&block).each_with_object(hash.class.new) do |key, seed|
+        seed[key] = hash[key]
+        seed[key] = sort_hash_by_key(seed[key], recursive: true, &block) if recursive && seed[key].is_a?(Hash)
+
+        seed
+      end
+    end
+
+    def self.split_user_query(user_query)
+      queries = user_query.split('.')
+      queries.map! { |query| /^[0-9]+$/.match?(query) ? query.to_i : query }
+    end
+
+    def self.deep_stringify_keys(object)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[key.to_s] = deep_stringify_keys(value)
+        end
+      when Array
+        object.map { |e| deep_stringify_keys(e) }
+      else
+        object
+      end
+    end
+
+    def self.try_to_bool(value)
+      case value.to_s
+      when 'true'
+        true
+      when 'false'
+        false
+      else
+        value
+      end
+    end
+
+    def self.try_to_int(value)
+      Integer(value)
+    rescue ArgumentError, TypeError
+      value
+    end
+  end
+end