facter 4.0.26 → 4.0.28

data/lib/resolvers/bsd/processors.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Bsd
+      class Processors < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { collect_processors_info(fact_name) }
+          end
+
+          def collect_processors_info(fact_name)
+            require "#{ROOT_DIR}/lib/resolvers/bsd/ffi/ffi_helper"
+
+            @fact_list[:logical_count] = logical_count
+            @fact_list[:models] = Array.new(logical_count, model) if logical_count && model
+            @fact_list[:speed] = speed * 1000 * 1000 if speed
+
+            @fact_list[fact_name]
+          end
+
+          CTL_HW = 6
+          HW_MODEL = 2
+          HW_NCPU = 3
+          HW_CPUSPEED = 12
+
+          def model
+            @model ||= Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_MODEL])
+          end
+
+          def logical_count
+            @logical_count ||= Facter::Bsd::FfiHelper.sysctl(:uint32_t, [CTL_HW, HW_NCPU])
+          end
+
+          def speed
+            @speed ||= Facter::Bsd::FfiHelper.sysctl(:uint32_t, [CTL_HW, HW_CPUSPEED])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/ec2.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'net/http'
+
+module Facter
+  module Resolvers
+    class Ec2 < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      EC2_METADATA_ROOT_URL = 'http://169.254.169.254/latest/meta-data/'
+      EC2_USERDATA_ROOT_URL = 'http://169.254.169.254/latest/user-data/'
+      EC2_CONNECTION_TIMEOUT = 0.6
+      EC2_SESSION_TIMEOUT = 5
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_facts(fact_name) }
+        end
+
+        def read_facts(fact_name)
+          @fact_list[:metadata] = {}
+          query_for_metadata(EC2_METADATA_ROOT_URL, @fact_list[:metadata])
+          @fact_list[:userdata] = get_data_from(EC2_USERDATA_ROOT_URL).strip
+          @fact_list[fact_name]
+        end
+
+        def query_for_metadata(url, container)
+          metadata = get_data_from(url)
+          metadata.each_line do |line|
+            next if line.empty?
+
+            http_path_component = build_path_compoent(line)
+            next if http_path_component == 'security-credentials/'
+
+            if http_path_component.end_with?('/')
+              child = {}
+              child[http_path_component] = query_for_metadata("#{url}#{http_path_component}", child)
+              child.reject! { |key, _info| key == http_path_component }
+              name = http_path_component.chomp('/')
+              container[name] = child
+            else
+              container[http_path_component] = get_data_from("#{url}#{http_path_component}").strip
+            end
+          end
+        end
+
+        def build_path_compoent(line)
+          array_match = /^(\d+)=.*$/.match(line)
+          array_match ? "#{array_match[1]}/" : line.strip
+        end
+
+        def get_data_from(url)
+          parsed_url = URI.parse(url)
+          http = Net::HTTP.new(parsed_url.host)
+          http.read_timeout = determine_session_timeout
+          http.open_timeout = EC2_CONNECTION_TIMEOUT
+          resp = http.get(parsed_url.path)
+          response_code_valid?(resp.code) ? resp.body : ''
+        rescue StandardError => e
+          log.debug("Trying to connect to #{url} but got: #{e.message}")
+          ''
+        end
+
+        def response_code_valid?(http_code)
+          http_code.to_i.equal?(200)
+        end
+
+        def determine_session_timeout
+          session_env = ENV['EC2_SESSION_TIMEOUT']
+          session_env ? session_env.to_i : EC2_SESSION_TIMEOUT
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/freebsd/ffi/ffi_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Freebsd
+    module FfiHelper
+      module Libc
+        extend FFI::Library
+
+        ffi_lib 'c'
+        attach_function :sysctlbyname, %i[string pointer pointer pointer size_t], :int
+      end
+
+      def self.sysctl_by_name(type, name)
+        oldp = FFI::Pointer::NULL
+        oldlenp = FFI::MemoryPointer.new(:size_t)
+
+        newp = FFI::Pointer::NULL
+        newlenp = 0
+
+        if type == :string
+          res = Libc.sysctlbyname(name, oldp, oldlenp, newp, newlenp)
+          return nil if res.negative?
+        else
+          oldlenp.write(:size_t, FFI.type_size(type))
+        end
+
+        oldp = FFI::MemoryPointer.new(:uint8_t, oldlenp.read(:size_t))
+        res = Libc.sysctlbyname(name, oldp, oldlenp, newp, newlenp)
+        return nil if res.negative?
+
+        case type
+        when :string
+          oldp.read_string
+        else
+          oldp.read(type)
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/freebsd/geom_resolver.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class Geom < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            require_relative 'ffi/ffi_helper'
+            require 'rexml/document'
+
+            read_disks
+            read_partitions
+
+            @fact_list[fact_name]
+          end
+
+          def read_disks
+            @fact_list[:disks] = {}
+
+            each_geom_class_provider('DISK') do |provider|
+              name = provider.get_text('./name').value
+
+              @fact_list[:disks][name] = %i[read_model read_serial_number read_size].map do |x|
+                send(x, provider)
+              end.inject(:merge)
+            end
+          end
+
+          def read_partitions
+            @fact_list[:partitions] = {}
+
+            each_geom_class_provider('PART') do |provider|
+              name = provider.get_text('./name').value
+
+              @fact_list[:partitions][name] = %i[read_partlabel read_partuuid read_size].map do |x|
+                send(x, provider)
+              end.inject(:merge)
+            end
+          end
+
+          def each_geom_class_provider(geom_class_name, &block)
+            REXML::XPath.each(geom_topology, "/mesh/class[name/text() = '#{geom_class_name}']/geom/provider", &block)
+          end
+
+          def read_size(provider)
+            res = {}
+            return res unless (mediasize = provider.get_text('mediasize'))
+
+            mediasize = Integer(mediasize.value)
+
+            res[:size_bytes] = mediasize
+            res[:size] = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(mediasize)
+            res
+          end
+
+          def read_model(provider)
+            res = {}
+            return res unless (model = provider.get_text('./config/descr'))
+
+            res[:model] = model.value
+            res
+          end
+
+          def read_partlabel(provider)
+            res = {}
+            return res unless (rawuuid = provider.get_text('./config/label'))
+
+            res[:partlabel] = rawuuid.value
+            res
+          end
+
+          def read_partuuid(provider)
+            res = {}
+            return res unless (rawuuid = provider.get_text('./config/rawuuid'))
+
+            res[:partuuid] = rawuuid.value
+            res
+          end
+
+          def read_serial_number(provider)
+            res = {}
+            return res unless (serial_number = provider.get_text('./config/ident'))
+
+            res[:serial_number] = serial_number.value
+            res
+          end
+
+          def geom_topology
+            @geom_topology ||= REXML::Document.new(geom_confxml)
+          end
+
+          def geom_confxml
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'kern.geom.confxml')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/freebsd/processors.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'resolvers/bsd/processors'
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class Processors < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { collect_processors_info(fact_name) }
+          end
+
+          def collect_processors_info(fact_name)
+            require "#{ROOT_DIR}/lib/resolvers/freebsd/ffi/ffi_helper"
+
+            @fact_list[:logical_count] = logical_count
+            @fact_list[:models] = Array.new(logical_count, model) if logical_count && model
+            @fact_list[:speed] = speed * 1000 * 1000 if speed
+
+            @fact_list[fact_name]
+          end
+
+          def model
+            @model ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'hw.model')
+          end
+
+          def logical_count
+            @logical_count ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.ncpu')
+          end
+
+          def speed
+            @speed ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.clockrate')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/macosx/networking.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Macosx
+      class Networking < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            primary_interface
+            dhcp
+            interfaces_data
+            unless @fact_list[:interfaces].nil?
+              ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list[:interfaces])
+            end
+            @fact_list[fact_name]
+          end
+
+          def primary_interface
+            result = Facter::Core::Execution.execute('route -n get default', logger: log)
+
+            @fact_list[:primary_interface] = result.match(/interface: (.+)/)&.captures&.first
+          end
+
+          def dhcp
+            return if @fact_list[:primary_interface].nil?
+
+            result = Facter::Core::Execution.execute("ipconfig getoption #{@fact_list[:primary_interface]} " \
+                                                       'server_identifier', logger: log)
+
+            @fact_list[:dhcp] = result.match(/^[\d.a-f:\s]+$/)&.to_s&.strip
+          end
+
+          def interfaces_data
+            command_response = Facter::Core::Execution.execute('ifconfig -a', logger: log)
+
+            clean_up_interfaces_response(command_response)
+            parse_interfaces_response(command_response)
+          end
+
+          def clean_up_interfaces_response(response)
+            # convert ip ranges into single ip. eg. 10.16.132.213 -->  10.16.132.213 is converted to 10.16.132.213
+            response.gsub!(/(\d+(\.\d+)*)\s+-->\s+\d+(\.\d+)*/, '\\1')
+          end
+
+          def parse_interfaces_response(response)
+            parsed_interfaces_data = {}
+            interfaces_data = Hash[*response.split(/^([A-Za-z0-9_]+): /)[1..-1]]
+
+            interfaces_data.each do |interface, properties|
+              values = {}
+
+              extract_mtu(properties, values)
+              extract_mac(properties, values)
+              extract_ip_data(properties, values)
+
+              parsed_interfaces_data[interface] = values
+            end
+            @fact_list[:interfaces] = parsed_interfaces_data unless parsed_interfaces_data.empty?
+          end
+
+          def extract_mtu(properties, values)
+            mtu = properties.match(/mtu\s+(\d+)/)&.captures&.first&.to_i
+            values[:mtu] = mtu unless mtu.nil?
+          end
+
+          def extract_mac(properties, values)
+            mac = properties.match(/(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/)&.captures&.first
+            values[:mac] = mac unless mac.nil?
+          end
+
+          def extract_ip_data(properties, values)
+            ip = extract_values(properties, /inet (\S+)/)
+            mask = extract_values(properties, /netmask (\S+)/).map { |val| val.hex.to_s(2).count('1') }
+
+            ip6 = extract_values(properties, /inet6 (\S+)/).map { |val| val.gsub(/%.+/, '') }
+            mask6 = extract_values(properties, /prefixlen (\S+)/)
+
+            values[:bindings] = create_bindings(ip, mask) unless ip.empty?
+            values[:bindings6] = create_bindings(ip6, mask6) unless ip6.empty?
+          end
+
+          def extract_values(data, regex)
+            results = []
+            data.scan(regex).flatten.each do |val|
+              results << val
+            end
+            results
+          end
+
+          def create_bindings(ips, masks)
+            bindings = []
+            ips.zip(masks).each do |ip, mask|
+              bindings << ::Resolvers::Utils::Networking.build_binding(ip, mask)
+            end
+            bindings
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/networking_linux_resolver.rb

@@ -46,6 +46,8 @@ module Facter
             find_dhcp!(ip_tokens, interfaces)
           end
 
+          ::Resolvers::Utils::Networking.expand_main_bindings(interfaces)
+
           @fact_list[:interfaces] = interfaces
         end
 
@@ -92,17 +94,10 @@ module Facter
 
           interface_name, ip4_address, ip4_mask_length = retrieve_name_and_ip_info(ip_tokens)
 
-          binding = build_binding(ip4_address, ip4_mask_length)
-          build_network_info_structure!(network_info, interface_name, 'bindings')
-
-          populate_other_ipv4_facts(network_info, interface_name, binding)
-        end
+          binding = ::Resolvers::Utils::Networking.build_binding(ip4_address, ip4_mask_length)
+          build_network_info_structure!(network_info, interface_name, :bindings)
 
-        def populate_other_ipv4_facts(network_info, interface_name, binding)
-          network_info[interface_name]['bindings'] << binding
-          network_info[interface_name][:ip] ||= binding[:address]
-          network_info[interface_name][:network] ||= binding[:network]
-          network_info[interface_name][:netmask] ||= binding[:netmask]
+          network_info[interface_name][:bindings] << binding
         end
 
         def retrieve_name_and_ip_info(tokens)
@@ -119,19 +114,12 @@ module Facter
 
           interface_name, ip6_address, ip6_mask_length = retrieve_name_and_ip_info(ip_tokens)
 
-          binding = build_binding(ip6_address, ip6_mask_length)
+          binding = ::Resolvers::Utils::Networking.build_binding(ip6_address, ip6_mask_length)
 
-          build_network_info_structure!(network_info, interface_name, 'bindings6')
+          build_network_info_structure!(network_info, interface_name, :bindings6)
 
           network_info[interface_name][:scope6] ||= ip_tokens[5]
-          populate_other_ipv6_facts(network_info, interface_name, binding)
-        end
-
-        def populate_other_ipv6_facts(network_info, interface_name, binding)
-          network_info[interface_name]['bindings6'] << binding
-          network_info[interface_name][:ip6] ||= binding[:address]
-          network_info[interface_name][:network6] ||= binding[:network]
-          network_info[interface_name][:netmask6] ||= binding[:netmask]
+          network_info[interface_name][:bindings6] << binding
         end
 
         def retrieve_default_interface
@@ -143,16 +131,6 @@ module Facter
           @fact_list[:primary_interface] = default_interface
         end
 
-        def build_binding(addr, mask_length)
-          require 'ipaddr'
-
-          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 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)