facter 4.5.1 → 4.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eb4ad4e8f37099548b19f8b37bc43b11b2f2ba2cfe28df31ffc30b4d8b6aac87
-  data.tar.gz: d978305277df30b5f97116aab7d96f1935de8e35db2cee3fdab1aa28db694a78
+  metadata.gz: d43b50edf3b5f7815e25fb42dc5cae9f15d2fb2dcbb5fd7146957667f48fa9cb
+  data.tar.gz: 2792c74d6509bddd13f391e9eaac528a5e8a8852fa6f276a433d2bddeb58d3d8
 SHA512:
-  metadata.gz: 9a0ebd49f8a7ddae37b97c4c2430b93f3fb18b462203daa6544bdfcdbdc28a3c4f1df5b90bbabb17a17fa2e8a1cef28f467e1b5cad70547c616e95e1051c1688
-  data.tar.gz: ef0687cb134a6d37e1d4a35ba8047ca134230e0834f5354fc8a3ce6463999b0f237c265b4dbf1d55f45a2cf12276f207f4c5756afd62bbcf2b61abb19ccf0eaa
+  metadata.gz: bac838d93cb84e7e3934e048368e69106182d25450979749228e2c32a8f2bd21792fd58c245e0cd7b18bbd9e5a11b6bf0edb7067435dd0948b4df25cef1517a8
+  data.tar.gz: b800f80520161b8ec33eb241811227565525c6bff880d271e78906b364c2e7d0fd4f54ac3984d7a6c93084c11de47788a0cd5549af770e91fbc3db9a65415deb

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/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.1' 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.1
+  version: 4.5.2
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-10-23 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