facter 4.5.0 → 4.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3bc6c44e0072feade1a48b1a15c423c6028dd18d66fd3edaed7aa7ae07ac4922
-  data.tar.gz: 452afdcc9dd049b23e43ea3623c5758c2447fec809a44680ab5928a65cd12b17
+  metadata.gz: d43b50edf3b5f7815e25fb42dc5cae9f15d2fb2dcbb5fd7146957667f48fa9cb
+  data.tar.gz: 2792c74d6509bddd13f391e9eaac528a5e8a8852fa6f276a433d2bddeb58d3d8
 SHA512:
-  metadata.gz: 77e545e417001ef58de71b4aa470ebbb4e71349d19c64eafce67268c019f41e1367b6bb00acc1c6e24586ee39f751a3f652c6227f7ccd16e300b7a4b3fbe10d2
-  data.tar.gz: c605efaacef975278de37d8d091ab251228d4f1d8c139e103eb2b50cbf0f3d49feac1f0b8f4c9f724b2a44e25bf1d832853ec28f82d0588afebe61b8a22a02b6
+  metadata.gz: bac838d93cb84e7e3934e048368e69106182d25450979749228e2c32a8f2bd21792fd58c245e0cd7b18bbd9e5a11b6bf0edb7067435dd0948b4df25cef1517a8
+  data.tar.gz: b800f80520161b8ec33eb241811227565525c6bff880d271e78906b364c2e7d0fd4f54ac3984d7a6c93084c11de47788a0cd5549af770e91fbc3db9a65415deb

data/lib/facter/custom_facts/util/directory_loader.rb

@@ -93,7 +93,12 @@ module LegacyFacter
           if data == false
             log.warn "Could not interpret fact file #{fact.file}"
           elsif (data == {}) || data.nil?
-            log.debug("Fact file #{fact.file} was parsed but no key=>value data was returned")
+            log.debug(
+              "Structured data fact file #{fact.file} was parsed but was either empty or an invalid filetype "\
+                '(valid filetypes are .yaml, .json, and .txt).'
+            )
+          elsif !data.is_a?(Hash)
+            log.error("Structured data fact file #{fact.file} was parsed but no key=>value data was returned.")
           else
             add_data(data, collection, fact, weight)
           end

data/lib/facter/facts/amzn/os/distro/release.rb

@@ -20,10 +20,15 @@ module Facts
           end
 
           def determine_release_version
+            # For backwards compatibility, use system-release for AL1/AL2
             version = Facter::Resolvers::ReleaseFromFirstLine.resolve(:release, release_file: '/etc/system-release')
+            if !version.nil? && version != '2'
+              # Use os-release for AL2023 and up
+              version = Facter::Resolvers::Amzn::OsReleaseRpm.resolve(:version)
+            end
             version ||= Facter::Resolvers::OsRelease.resolve(:version_id)
 
-            Facter::Util::Facts.release_hash_from_string(version)
+            Facter::Util::Facts.release_hash_from_string(version, include_patch: true)
           end
         end
       end

data/lib/facter/facts/amzn/os/release.rb

@@ -18,7 +18,12 @@ module Facts
         end
 
         def determine_release_version
+          # For backwards compatibility, use system-release for AL1/AL2
           version = Facter::Resolvers::ReleaseFromFirstLine.resolve(:release, release_file: '/etc/system-release')
+          if !version.nil? && version != '2'
+            # Use os-release for AL2023 and up
+            version = Facter::Resolvers::Amzn::OsReleaseRpm.resolve(:version)
+          end
           version ||= Facter::Resolvers::OsRelease.resolve(:version_id)
 
           Facter::Util::Facts.release_hash_from_string(version)

data/lib/facter/framework/core/fact_loaders/class_discoverer.rb

@@ -21,9 +21,10 @@ module Facter
 
     def find_nested_classes(mod, discovered_classes)
       mod.constants.each do |constant_name|
-        if mod.const_get(constant_name).instance_of? Class
-          discovered_classes << mod.const_get(constant_name)
-        elsif mod.const_get(constant_name).instance_of? Module
+        obj = mod.const_get(constant_name)
+        if obj.instance_of? Class
+          discovered_classes << obj
+        elsif obj.instance_of? Module
           find_nested_classes(Module.const_get("#{mod.name}::#{constant_name}"), discovered_classes)
         end
       end

data/lib/facter/framework/core/file_loader.rb

@@ -244,6 +244,8 @@ os_hierarchy.each do |os|
     require_relative '../../facts/amzn/os/distro/release.rb'
     require_relative '../../facts/amzn/os/release.rb'
 
+    require_relative '../../resolvers/amzn/os_release_rpm'
+
   when 'bsd'
     require_relative '../../facts/bsd/kernelmajversion.rb'
     require_relative '../../facts/bsd/kernelversion.rb'

data/lib/facter/framework/parsers/query_parser.rb

@@ -18,18 +18,18 @@ module Facter
       # Because a root fact will always be resolved by a collection of child facts,
       # we can return one or more child facts for each parent.
       #
-      # query -  is the user input used to search for facts
-      # loaded_fact - is a list with all facts for the current operating system
+      # @param query_list [Array] The list of facts to search for
+      # @param loaded_facts [Array] All of the fact definitions for the current operating system
       #
-      # Returns a list of SearchedFact objects that resolve the users query.
-      def parse(query_list, loaded_fact)
+      # @return [Array<SearchedFact>] a list of searchable facts that resolve the user's query
+      def parse(query_list, loaded_facts)
         matched_facts = []
         @query_list = query_list
 
-        return no_user_query(loaded_fact) unless query_list.any?
+        return no_user_query(loaded_facts) unless query_list.any?
 
         query_list.each do |query|
-          found_facts = search_for_facts(query, loaded_fact)
+          found_facts = search_for_facts(query, loaded_facts)
           matched_facts << found_facts
         end
 
@@ -44,15 +44,17 @@ module Facter
         searched_facts
       end
 
-      def search_for_facts(query, loaded_fact_hash)
+      def search_for_facts(query, loaded_facts)
         resolvable_fact_list = []
         query = query.to_s
         query_tokens = query.end_with?('.*') ? [query] : query.split('.')
         size = query_tokens.size
 
+        # Try to match the most specific query_tokens to the least, returning the first match
         size.times do |i|
           query_token_range = 0..size - i - 1
-          resolvable_fact_list = get_facts_matching_tokens(query_tokens, query_token_range, loaded_fact_hash)
+          query_fact = query_tokens[query_token_range].join('.')
+          resolvable_fact_list = get_facts_matching_tokens(query_tokens, query_fact, loaded_facts)
 
           return resolvable_fact_list if resolvable_fact_list.any?
         end
@@ -62,12 +64,10 @@ module Facter
         resolvable_fact_list
       end
 
-      def get_facts_matching_tokens(query_tokens, query_token_range, loaded_fact_hash)
+      def get_facts_matching_tokens(query_tokens, query_fact, loaded_facts)
         resolvable_fact_list = []
 
-        loaded_fact_hash.each do |loaded_fact|
-          query_fact = query_tokens[query_token_range].join('.')
-
+        loaded_facts.each do |loaded_fact|
           next unless found_fact?(loaded_fact.name, query_fact)
 
           searched_fact = construct_loaded_fact(query_tokens, loaded_fact)
@@ -79,16 +79,20 @@ module Facter
       end
 
       def found_fact?(fact_name, query_fact)
+        # This is the case where the fact_name contains a wildcard like
+        # blockdevice_.*_model and we're querying for the legacy fact
+        # specifically using 'blockdevice_sba_model' and we don't want the query
+        # 'blockdevice.sba.model' to match
         fact_with_wildcard = fact_name.include?('.*') && !query_fact.include?('.')
 
-        processed_equery_fact = query_fact.gsub('\\', '\\\\\\\\')
-
-        return false if fact_with_wildcard && !query_fact.match("^#{fact_name}$")
-
-        # Must escape metacharacters (like dots) to ensure the correct fact is found
-        return false unless fact_with_wildcard || fact_name.match("^#{Regexp.escape(processed_equery_fact)}($|\\.)")
-
-        true
+        if fact_with_wildcard
+          # fact_name contains wildcard, so we're intentially not escaping.
+          query_fact.match("^#{fact_name}$")
+        else
+          processed_equery_fact = query_fact.gsub('\\', '\\\\\\\\')
+          # Must escape metacharacters (like dots) to ensure the correct fact is found
+          fact_name.match("^#{Regexp.escape(processed_equery_fact)}($|\\.)")
+        end
       end
 
       def construct_loaded_fact(query_tokens, loaded_fact)

data/lib/facter/resolvers/aix/disks.rb

@@ -47,7 +47,7 @@ module Facter
           end
 
           def compute_size(size_hash)
-            physical_partitions = size_hash['TOTAL PPs'].to_i + size_hash['FREE PPs'].to_i
+            physical_partitions = size_hash['TOTAL PPs'].to_i
             size_physical_partition = size_hash['PP SIZE']
             exp = if size_physical_partition[/mega/]
                     Facter::Util::Aix::InfoExtractor::MEGABYTES_EXPONENT

data/lib/facter/resolvers/aix/partitions.rb

@@ -56,14 +56,14 @@ module Facter
           end
 
           def compute_size(info_hash)
-            physical_partitions = info_hash['PPs'].to_i
+            logical_partitions = info_hash['LPs'].to_i
             size_physical_partition = info_hash['PP SIZE']
             exp = if size_physical_partition[/mega/]
                     Facter::Util::Aix::InfoExtractor::MEGABYTES_EXPONENT
                   else
                     Facter::Util::Aix::InfoExtractor::GIGABYTES_EXPONENT
                   end
-            size_physical_partition.to_i * physical_partitions * exp
+            size_physical_partition.to_i * logical_partitions * exp
           end
         end
       end

data/lib/facter/resolvers/amzn/os_release_rpm.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Amzn
+      class OsReleaseRpm < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { rpm_system_call(fact_name) }
+          end
+
+          def rpm_system_call(fact_name)
+            output = Facter::Core::Execution.execute(
+              'rpm -q --qf \'%{NAME}\n%{VERSION}\n%{RELEASE}\n%{VENDOR}\' -f /etc/os-release',
+              logger: log
+            )
+            build_fact_list(output)
+
+            @fact_list[fact_name]
+          end
+
+          def build_fact_list(output)
+            rpm_results = output.split("\n")
+
+            return if rpm_results.empty?
+
+            @fact_list[:package],
+              @fact_list[:version],
+              @fact_list[:release],
+              @fact_list[:vendor] = rpm_results.map(&:strip)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/freebsd/system_memory.rb

@@ -15,25 +15,33 @@ module Facter
 
           def calculate_system_memory(fact_name)
             read_total_memory_in_bytes
-            read_available_memory_in_bytes
+            read_used_memory_in_bytes
 
-            @fact_list[:used_bytes] = @fact_list[:total_bytes] - @fact_list[:available_bytes]
+            @fact_list[:available_bytes] = @fact_list[:total_bytes] - @fact_list[:used_bytes]
             @fact_list[:capacity] = Facter::Util::Resolvers::FilesystemHelper
                                     .compute_capacity(@fact_list[:used_bytes], @fact_list[:total_bytes])
 
             @fact_list[fact_name]
           end
 
-          def read_available_memory_in_bytes
-            output = Facter::Core::Execution.execute('vmstat -H --libxo json', logger: log)
-            data = JSON.parse(output)
-            @fact_list[:available_bytes] = data['memory']['free-memory'] * 1024
+          def pagesize
+            @pagesize ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'vm.stats.vm.v_page_size')
+          end
+
+          def read_used_memory_in_bytes
+            require_relative 'ffi/ffi_helper'
+
+            @fact_list[:used_bytes] = pagesize * (
+              Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'vm.stats.vm.v_active_count') +
+              Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'vm.stats.vm.v_wire_count')
+            )
           end
 
           def read_total_memory_in_bytes
             require_relative 'ffi/ffi_helper'
 
-            @fact_list[:total_bytes] = Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'hw.physmem')
+            @fact_list[:total_bytes] = pagesize *
+                                       Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'vm.stats.vm.v_page_count')
           end
         end
       end

data/lib/facter/resolvers/solaris/dmi_sparc.rb

@@ -19,6 +19,12 @@ module Facter
 
             matches = output.match(/System Configuration:\s+(.+?)\s+sun\d+\S+\s+(.+)/)&.captures
 
+            # There are circumstances (e.g. in non-global zones) when prtdiag
+            # will return text, but it's an error message or some other string
+            # that isn't parsed by the above match/capture. In that case, we
+            # simply return.
+            return if matches.nil?
+
             @fact_list[:manufacturer] = matches[0]&.strip
             @fact_list[:product_name] = matches[1]&.strip
 

data/lib/facter/resolvers/solaris/ffi/functions.rb

@@ -10,7 +10,7 @@ module Facter
 
           attach_function :ioctl_base, :ioctl, %i[int int pointer], :int
           attach_function :open_socket, :socket, %i[int int int], :int
-          attach_function :close_socket, :shutdown, %i[int int], :int
+          attach_function :close_socket, :close, %i[int], :int
           attach_function :inet_ntop, %i[int pointer pointer uint], :string
 
           def self.ioctl(call_const, pointer, address_family = AF_INET)
@@ -18,7 +18,7 @@ module Facter
             begin
               ioctl_base(fd, call_const, pointer)
             ensure
-              Ioctl.close_socket(fd, 2)
+              Ioctl.close_socket(fd)
             end
           end
         end

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

@@ -79,7 +79,7 @@ module Facter
             ioctl = FFI::Ioctl.ioctl(FFI::SIOCGLIFMTU, lifreq, lifreq.ss_family)
 
             if ioctl == -1
-              @log.error("Cold not read MTU, error code is #{::FFI::LastError.error}")
+              @log.error("Could not read MTU, error code is: #{::FFI::LastError.error}")
               return
             end
 

data/lib/facter/resolvers/uname.rb

@@ -28,12 +28,16 @@ module Facter
         def build_fact_list(output)
           uname_results = output.split("\n")
 
-          @fact_list[:machine] = uname_results[0].strip
-          @fact_list[:nodename] = uname_results[1].strip
-          @fact_list[:processor] = uname_results[2].strip
-          @fact_list[:kernelrelease] = uname_results[3].strip
-          @fact_list[:kernelname] = uname_results[4].strip
-          @fact_list[:kernelversion] = uname_results[5].strip
+          if !uname_results.empty?
+            @fact_list[:machine],
+            @fact_list[:nodename],
+            @fact_list[:processor],
+            @fact_list[:kernelrelease],
+            @fact_list[:kernelname],
+            @fact_list[:kernelversion] = uname_results.map(&:strip)
+          else
+            log.warn('Request to uname returned no output. Uname related facts are not populated.')
+          end
         end
       end
     end

data/lib/facter/resolvers/xen.rb

@@ -26,7 +26,9 @@ module Facter
 
         def detect_xen_type
           xen_type = 'xen0' if File.exist?('/dev/xen/evtchn')
-          xen_type = 'xenu' if !xen_type && (File.exist?('/proc/xen') || File.exist?('/dev/xvda1'))
+          if !xen_type && (File.exist?('/proc/xen') || (File.exist?('/dev/xvda1') && !File.symlink?('/dev/xvda1')))
+            xen_type = 'xenu'
+          end
 
           xen_type
         end

data/lib/facter/util/aix/info_extractor.rb

@@ -61,7 +61,7 @@ module Facter
           properties = PROPERTIES[cmd]
           properties.each do |property|
             str = (properties - [property]).join('|')
-            matcher = content.match(/#{Regexp.escape(property)}([^\n]*?)(#{str}|\n|$)/s)
+            matcher = content.match(/(?:^|^[^:]+:[^:]+)#{Regexp.escape(property)}([^\n]*?)(#{str}|\n|$)/s)
             if matcher
               value = matcher[1].strip
               property_hash[property.split(':').first] = value

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

@@ -25,7 +25,7 @@ module Facter
           os
         end
 
-        def release_hash_from_string(output)
+        def release_hash_from_string(output, include_patch: false)
           return unless output
 
           versions = output.split('.')
@@ -33,6 +33,7 @@ module Facter
             release['full'] = output
             release['major'] = versions[0]
             release['minor'] = versions[1] if versions[1]
+            release['patch'] = versions[2] if versions[2] && include_patch
           end
         end
 

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

@@ -3,13 +3,7 @@
 module Facter
   module Util
     module Resolvers
-      class FingerPrint
-        attr_accessor :sha1, :sha256
-        def initialize(sha1, sha256)
-          @sha1 = sha1
-          @sha256 = sha256
-        end
-      end
+      FingerPrint = Struct.new(:sha1, :sha256)
     end
   end
 end

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

@@ -57,6 +57,8 @@ module Facter
             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])

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

@@ -3,15 +3,7 @@
 module Facter
   module Util
     module Resolvers
-      class Ssh
-        attr_accessor :fingerprint, :type, :key, :name
-        def initialize(fingerprint, type, key, name)
-          @fingerprint = fingerprint
-          @type = type
-          @key = key
-          @name = name
-        end
-      end
+      Ssh = Struct.new(:fingerprint, :type, :key, :name)
     end
   end
 end

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

@@ -9,6 +9,7 @@ module Facter
       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
 
@@ -16,6 +17,7 @@ module Facter
             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)}"

data/lib/facter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Facter
-  VERSION = '4.5.0' unless defined?(VERSION)
+  VERSION = '4.5.2' unless defined?(VERSION)
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: facter
 version: !ruby/object:Gem::Version
-  version: 4.5.0
+  version: 4.5.2
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-09-26 00:00:00.000000000 Z
+date: 2024-01-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -934,6 +934,7 @@ files:
 - lib/facter/resolvers/aix/partitions.rb
 - lib/facter/resolvers/aix/processors.rb
 - lib/facter/resolvers/aix/serialnumber.rb
+- lib/facter/resolvers/amzn/os_release_rpm.rb
 - lib/facter/resolvers/augeas.rb
 - lib/facter/resolvers/az.rb
 - lib/facter/resolvers/base_resolver.rb
@@ -1101,7 +1102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.12
+rubygems_version: 3.4.20
 signing_key: 
 specification_version: 4
 summary: Facter, a system inventory tool