facter 4.4.2 → 4.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c01a91258966862aa3d5b43fca18899206b64cefa3fd42446ac1c012132e90ea
-  data.tar.gz: 3e1c32c10e166a3dcb8ed55d709b4ce8cbe9c56b9238ed42964519caf48b82be
+  metadata.gz: 3bc6c44e0072feade1a48b1a15c423c6028dd18d66fd3edaed7aa7ae07ac4922
+  data.tar.gz: 452afdcc9dd049b23e43ea3623c5758c2447fec809a44680ab5928a65cd12b17
 SHA512:
-  metadata.gz: a9f7a49e2297d1dd06b1544118e58a5cba75aa04a5991e61e3450039ff86caa934c30d1d7b584d4432a081d010be6f978f6bc6fef8cfdfa38367ec858f0a2754
-  data.tar.gz: c7793db89e1fd72269eba0b1f195942020a60d699374b661cd87f418be2aff38cb128ab45d0959696e696601c0bb70b7715d85c5c6404bb1aa77e9727e5f659b
+  metadata.gz: 77e545e417001ef58de71b4aa470ebbb4e71349d19c64eafce67268c019f41e1367b6bb00acc1c6e24586ee39f751a3f652c6227f7ccd16e300b7a4b3fbe10d2
+  data.tar.gz: c605efaacef975278de37d8d091ab251228d4f1d8c139e103eb2b50cbf0f3d49feac1f0b8f4c9f724b2a44e25bf1d832853ec28f82d0588afebe61b8a22a02b6

data/lib/facter/custom_facts/core/aggregate.rb

@@ -53,6 +53,13 @@ module Facter
       # @api private
       attr_reader :fact
 
+      # @!attribute [r] last_evaluated
+      #
+      # @return [String]
+      #
+      # @api public
+      attr_reader :last_evaluated
+
       # Create a new aggregated resolution mechanism.
       #
       # @param name [String] The name of the resolution.
@@ -101,7 +108,15 @@ module Facter
       #
       # @api private
       def evaluate(&block)
+        if @last_evaluated
+          msg = "Already evaluated #{@name}"
+          msg << " at #{@last_evaluated}" if msg.is_a? String
+          msg << ', reevaluating anyways'
+          log.warn msg
+        end
         instance_eval(&block)
+
+        @last_evaluated = block.source_location.join(':')
       end
 
       # Define a new chunk for the given aggregate

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

@@ -85,7 +85,9 @@ module Facter
 
         resolve
       rescue StandardError => e
-        log.log_exception("Unable to add resolve #{resolution_name.inspect} for fact #{@name}: #{e.message}")
+        msg = "Unable to add resolve #{resolution_name.inspect} for fact '#{@name}': #{e.message}"
+        msg += "\n" + e.backtrace.join("\n") if Options[:trace]
+        log.error(msg, true)
         nil
       end
 
@@ -223,8 +225,7 @@ module Facter
       end
 
       def log_fact_path(resolve)
-        fact = resolve.fact
-        log.debug("#{resolve.fact_type} fact #{fact.name} got resolved from: #{fact.location}")
+        log.debug("#{resolve.fact_type} fact #{resolve.fact.name} was resolved from: #{resolve.last_evaluated}")
       end
 
       def announce_when_no_suitable_resolution(resolutions)

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

@@ -96,14 +96,7 @@ module Facter
 
         instance_eval(&block)
 
-        # Ruby 1.9+ provides the source location of procs which can provide useful
-        # debugging information if a resolution is being evaluated twice. Since 1.8
-        # doesn't support this we opportunistically provide this information.
-        @last_evaluated = if block.respond_to? :source_location
-                            block.source_location.join(':')
-                          else
-                            true
-                          end
+        @last_evaluated = block.source_location.join(':')
       end
 
       # Sets options for the aggregate fact

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

@@ -6,6 +6,9 @@ module LegacyFacter
       def self.root?
         require_relative '../../../facter/resolvers/windows/ffi/identity_ffi'
         IdentityFFI.privileged?
+      rescue LoadError => e
+        log = Facter::Log.new(self)
+        log.debug("The ffi gem has not been installed: #{e}")
       end
     end
   end

data/lib/facter/facts/macosx/os/macosx/version.rb

@@ -10,23 +10,27 @@ module Facts
                        macosx_productversion_patch].freeze
 
           def call_the_resolver
-            fact_value = Facter::Resolvers::SwVers.resolve(:productversion)
-            ver = version_hash(fact_value)
+            version_value = Facter::Resolvers::SwVers.resolve(:productversion)
+            extra_value = Facter::Resolvers::SwVers.resolve(:productversionextra)
+            ver = version_hash(version_value, extra_value)
 
             [Facter::ResolvedFact.new(FACT_NAME, ver),
-             Facter::ResolvedFact.new(ALIASES[0], fact_value, :legacy),
+             Facter::ResolvedFact.new(ALIASES[0], version_value, :legacy),
              Facter::ResolvedFact.new(ALIASES[1], ver['major'], :legacy),
              Facter::ResolvedFact.new(ALIASES[2], ver['minor'], :legacy),
              Facter::ResolvedFact.new(ALIASES[3], ver['patch'], :legacy)]
           end
 
-          def version_hash(fact_value)
-            versions = fact_value.split('.')
+          def version_hash(version_value, extra_value)
+            versions = version_value.split('.')
             if versions[0] == '10'
-              { 'full' => fact_value, 'major' => "#{versions[0]}.#{versions[1]}", 'minor' => versions[-1] }
-            else
-              { 'full' => fact_value, 'major' => versions[0], 'minor' => versions.fetch(1, '0'),
+              { 'full' => version_value, 'major' => "#{versions[0]}.#{versions[1]}", 'minor' => versions[-1] }
+            elsif /11|12/.match?(versions[0]) || extra_value.nil?
+              { 'full' => version_value, 'major' => versions[0], 'minor' => versions.fetch(1, '0'),
                 'patch' => versions.fetch(2, '0') }
+            else
+              { 'full' => version_value, 'major' => versions[0], 'minor' => versions.fetch(1, '0'),
+                'patch' => versions.fetch(2, '0'), 'extra' => extra_value }
             end
           end
         end

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

@@ -28,9 +28,13 @@ module Facter
             @fact_list[:interfaces] = Facter::Util::Linux::SocketParser.retrieve_interfaces(log)
             mtu_and_indexes = interfaces_mtu_and_index
 
-            @fact_list[:interfaces].keys.each do |interface_name|
-              mtu(interface_name, mtu_and_indexes)
-              dhcp(interface_name, mtu_and_indexes)
+            @fact_list[:interfaces].each_pair do |interface_name, iface|
+              mtu(interface_name, mtu_and_indexes, iface)
+              dhcp(interface_name, mtu_and_indexes, iface)
+              operstate(interface_name, iface)
+              physical(interface_name, iface)
+              linkspeed(interface_name, iface)
+              duplex(interface_name, iface)
 
               @log.debug("Found interface #{interface_name} with #{@fact_list[:interfaces][interface_name]}")
             end
@@ -47,6 +51,43 @@ module Facter
             mtu_and_indexes
           end
 
+          def operstate(interface_name, iface)
+            state = Facter::Util::FileHelper.safe_read("/sys/class/net/#{interface_name}/operstate", nil)
+            iface[:operational_state] = state.strip if state
+          end
+
+          def physical(ifname, iface)
+            iface[:physical] = if File.exist?("/sys/class/net/#{ifname}/device")
+                                 true
+                               else
+                                 false
+                               end
+          end
+
+          def duplex(interface_name, iface)
+            return unless iface[:physical]
+
+            # not all interfaces support this, wifi for example causes an EINVAL (Invalid argument)
+            begin
+              plex = Facter::Util::FileHelper.safe_read("/sys/class/net/#{interface_name}/duplex", nil)
+              iface[:duplex] = plex.strip if plex
+            rescue StandardError => e
+              @log.debug("Failed to read '/sys/class/net/#{interface_name}/duplex': #{e.message}")
+            end
+          end
+
+          def linkspeed(interface_name, iface)
+            return unless iface[:physical]
+
+            # not all interfaces support this, wifi for example causes an EINVAL (Invalid argument)
+            begin
+              speed = Facter::Util::FileHelper.safe_read("/sys/class/net/#{interface_name}/speed", nil)
+              iface[:speed] = speed.strip.to_i if speed
+            rescue StandardError => e
+              @log.debug("Failed to read '/sys/class/net/#{interface_name}/speed': #{e.message}")
+            end
+          end
+
           def parse_ip_command_line(line, mtu_and_indexes)
             mtu = line.match(/mtu (\d+)/)&.captures&.first&.to_i
             index_tokens = line.split(':')
@@ -56,14 +97,14 @@ module Facter
             mtu_and_indexes[name] = { index: index, mtu: mtu }
           end
 
-          def mtu(interface_name, mtu_and_indexes)
+          def mtu(interface_name, mtu_and_indexes, iface)
             mtu = mtu_and_indexes.dig(interface_name, :mtu)
-            @fact_list[:interfaces][interface_name][:mtu] = mtu unless mtu.nil?
+            iface[:mtu] = mtu unless mtu.nil?
           end
 
-          def dhcp(interface_name, mtu_and_indexes)
+          def dhcp(interface_name, mtu_and_indexes, iface)
             dhcp = Facter::Util::Linux::Dhcp.dhcp(interface_name, mtu_and_indexes.dig(interface_name, :index), log)
-            @fact_list[:interfaces][interface_name][:dhcp] = dhcp unless dhcp.nil?
+            iface[:dhcp] = dhcp unless dhcp.nil?
           end
 
           def add_info_from_routing_table

data/lib/facter/resolvers/macosx/mountpoints.rb

@@ -7,6 +7,8 @@ module Facter
         include Facter::Util::Resolvers::FilesystemHelper
         init_resolver
 
+        @log = Facter::Log.new(self)
+
         class << self
           private
 
@@ -16,18 +18,21 @@ module Facter
 
           def read_mounts
             mounts = {}
+            begin
+              Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |fs|
+                device = fs.name
+                filesystem = fs.mount_type
+                path = fs.mount_point
+                options = read_options(fs.options)
 
-            Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |fs|
-              device = fs.name
-              filesystem = fs.mount_type
-              path = fs.mount_point
-              options = read_options(fs.options)
-
-              mounts[path] = read_stats(path).tap do |hash|
-                hash[:device] = device
-                hash[:filesystem] = filesystem
-                hash[:options] = options if options.any?
+                mounts[path] = read_stats(path).tap do |hash|
+                  hash[:device] = device
+                  hash[:filesystem] = filesystem
+                  hash[:options] = options if options.any?
+                end
               end
+            rescue LoadError => e
+              @log.debug("Could not read mounts: #{e}")
             end
 
             @fact_list[:mountpoints] = mounts
@@ -39,7 +44,7 @@ module Facter
               size_bytes = stats.bytes_total
               available_bytes = stats.bytes_available
               used_bytes = size_bytes - available_bytes
-            rescue Sys::Filesystem::Error
+            rescue Sys::Filesystem::Error, LoadError
               size_bytes = used_bytes = available_bytes = 0
             end
 

data/lib/facter/resolvers/mountpoints.rb

@@ -45,14 +45,20 @@ module Facter
 
         def read_mounts(fact_name)
           mounts = []
-          Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |file_system|
-            mount = {}
-            get_mount_data(file_system, mount)
-
-            next if mount[:path] =~ %r{^/(proc|sys)} && mount[:filesystem] != 'tmpfs' || mount[:filesystem] == 'autofs'
-
-            get_mount_sizes(mount)
-            mounts << mount
+          begin
+            Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |file_system|
+              mount = {}
+              get_mount_data(file_system, mount)
+
+              if mount[:path] =~ %r{^/(proc|sys)} && mount[:filesystem] != 'tmpfs' || mount[:filesystem] == 'autofs'
+                next
+              end
+
+              get_mount_sizes(mount)
+              mounts << mount
+            end
+          rescue LoadError => e
+            @log.debug("Could not read mounts: #{e}")
           end
 
           @fact_list[:mountpoints] = mounts
@@ -70,7 +76,7 @@ module Facter
           begin
             stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(mount[:path])
             get_bytes_data(mount, stats)
-          rescue Sys::Filesystem::Error => e
+          rescue LoadError, Sys::Filesystem::Error => e
             @log.debug("Could not get stats for mountpoint #{mount[:path]}, got #{e}")
             mount[:size_bytes] = mount[:available_bytes] = mount[:used_bytes] = 0
           end

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

@@ -7,6 +7,8 @@ module Facter
         include Facter::Util::Resolvers::FilesystemHelper
         init_resolver
 
+        @log = Facter::Log.new(self)
+
         class << self
           private
 
@@ -24,31 +26,34 @@ module Facter
           def read_mounts(fact_name) # rubocop:disable Metrics/MethodLength
             @mounts = []
             @auto_home_paths = []
+            begin
+              Facter::Util::Resolvers::FilesystemHelper.read_mountpoints&.each do |fs|
+                if fs.name == 'auto_home'
+                  @auto_home_paths << fs.mount_point
+                  next
+                end
 
-            Facter::Util::Resolvers::FilesystemHelper.read_mountpoints&.each do |fs|
-              if fs.name == 'auto_home'
-                @auto_home_paths << fs.mount_point
-                next
-              end
+                next if fs.mount_type == 'autofs'
 
-              next if fs.mount_type == 'autofs'
+                mounts = {}
+                device = fs.name
+                filesystem = fs.mount_type
+                path = fs.mount_point
+                options = fs.options.split(',').map(&:strip)
 
-              mounts = {}
-              device = fs.name
-              filesystem = fs.mount_type
-              path = fs.mount_point
-              options = fs.options.split(',').map(&:strip)
+                mounts = read_stats(path).tap do |hash|
+                  hash[:device] = device
+                  hash[:filesystem] = filesystem
+                  hash[:path] = path
+                  hash[:options] = options if options.any?
+                end
 
-              mounts = read_stats(path).tap do |hash|
-                hash[:device] = device
-                hash[:filesystem] = filesystem
-                hash[:path] = path
-                hash[:options] = options if options.any?
+                @mounts << Hash[Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
+                                .zip(Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
+                  .map { |v| mounts[v] })]
               end
-
-              @mounts << Hash[Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
-                              .zip(Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
-                .map { |v| mounts[v] })]
+            rescue LoadError => e
+              @log.debug("Could not read mounts: #{e}")
             end
 
             exclude_auto_home_mounts!
@@ -64,7 +69,7 @@ module Facter
               available_bytes = stats.bytes_available.abs
               used_bytes = stats.bytes_used.abs
               total_bytes = used_bytes + available_bytes
-            rescue Sys::Filesystem::Error
+            rescue Sys::Filesystem::Error, LoadError
               size_bytes = used_bytes = available_bytes = 0
             end
 

data/lib/facter/resolvers/sw_vers.rb

@@ -5,6 +5,7 @@ module Facter
     class SwVers < BaseResolver
       # :productname
       # :productversion
+      # :productversionextra
       # :buildversion
 
       init_resolver

data/lib/facter/resolvers/windows/hardware_architecture.rb

@@ -23,6 +23,9 @@ module Facter
           arch = determine_architecture(hard)
           build_facts_list(hardware: hard, architecture: arch)
           @fact_list[fact_name]
+        rescue LoadError => e
+          log = Facter::Log.new(self)
+          log.debug("The ffi gem has not been installed: #{e}")
         end
 
         def determine_hardware(sys_info)

data/lib/facter/resolvers/windows/identity.rb

@@ -32,6 +32,8 @@ module Facter
           end
 
           { user: name_ptr.read_wide_string_with_length(size_ptr.read_uint32), privileged: IdentityFFI.privileged? }
+        rescue LoadError => e
+          @log.debug("Could not find username: #{e}")
         end
 
         def retrieve_facts(fact_name)

data/lib/facter/resolvers/windows/kernel.rb

@@ -30,6 +30,8 @@ module Facter
           build_facts_list(result)
 
           @fact_list[fact_name]
+        rescue LoadError => e
+          @log.debug("Could not get OS version information: #{e}")
         end
 
         def build_facts_list(result)

data/lib/facter/resolvers/windows/memory.rb

@@ -28,6 +28,8 @@ module Facter
           @long_living_pointer = state_ptr
 
           PerformanceInformation.new(state_ptr)
+        rescue LoadError => e
+          @log.debug("Could not resolve memory facts: #{e}")
         end
 
         def calculate_memory

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

@@ -31,6 +31,8 @@ module Facter
             Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
 
             @fact_list[fact_name]
+          rescue LoadError => e
+            @log.debug("The ffi gem has not been installed: #{e}")
           end
 
           def get_adapter_addresses(size_ptr, adapter_addresses, flags)

data/lib/facter/resolvers/windows/system32.rb

@@ -31,6 +31,8 @@ module Facter
           end
 
           @fact_list[:system32] = construct_path(bool_ptr, windows_path)
+        rescue LoadError => e
+          @log.debug("Could not retrieve: #{e}")
         end
 
         def construct_path(bool_ptr, windows)

data/lib/facter/resolvers/windows/timezone.rb

@@ -33,6 +33,9 @@ module Facter
           def codepage_from_api
             require_relative '../../../facter/resolvers/windows/ffi/winnls_ffi'
             WinnlsFFI.GetACP.to_s
+          rescue LoadError => e
+            log = Facter::Log.new(self)
+            log.debug("Could not retrieve codepage: #{e}")
           end
         end
       end

data/lib/facter/util/file_helper.rb

@@ -22,13 +22,12 @@ module Facter
           default_return
         end
 
+        # 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)
-          children = if RUBY_VERSION.to_f < 2.5
-                       Dir.entries(path).reject { |dir| ['.', '..'].include?(dir) }
-                     else
-                       Dir.children(path)
-                     end
-
+          children = Dir.children(path)
           children
         end
 

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

@@ -9,9 +9,7 @@ module Facter
                         size_bytes used used_bytes capacity].freeze
         class << self
           def read_mountpoints
-            # TODO: this require must be replaced with "require 'sys/filesystem'" when a new release of
-            # djberg96/sys-filesystem gem is available
-            require_relative '../../patches/sysfilesystem/sys/statvfs.rb'
+            require 'sys/filesystem'
             force_utf(Sys::Filesystem.mounts)
           end
 

data/lib/facter/version.rb

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

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: facter
 version: !ruby/object:Gem::Version
-  version: 4.4.2
+  version: 4.5.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-08-17 00:00:00.000000000 Z
+date: 2023-09-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.15.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.15.5
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -106,14 +120,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -903,7 +917,6 @@ files:
 - lib/facter/models/loaded_fact.rb
 - lib/facter/models/resolved_fact.rb
 - lib/facter/models/searched_fact.rb
-- lib/facter/patches/sysfilesystem/sys/statvfs.rb
 - lib/facter/resolvers/aio_agent_version.rb
 - lib/facter/resolvers/aix/architecture.rb
 - lib/facter/resolvers/aix/disks.rb

data/lib/facter/patches/sysfilesystem/sys/statvfs.rb

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-require 'sys/filesystem'
-
-module Sys
-  class Filesystem
-    module Structs
-      class Statvfs < FFI::Struct
-        # We must remove the instance variable layout defined by sys-filesystem, because setting
-        # it the second time will make FFI log a warning message.
-        remove_instance_variable(:@layout) if @layout
-
-        if /darwin|osx|mach/i.match?(RbConfig::CONFIG['host_os'])
-          layout(
-            :f_bsize, :ulong,
-            :f_frsize, :ulong,
-            :f_blocks, :uint,
-            :f_bfree, :uint,
-            :f_bavail, :uint,
-            :f_files, :uint,
-            :f_ffree, :uint,
-            :f_favail, :uint,
-            :f_fsid, :ulong,
-            :f_flag, :ulong,
-            :f_namemax, :ulong
-          )
-        elsif /bsd/i.match?(RbConfig::CONFIG['host'])
-          layout(
-            :f_bavail, :uint64,
-            :f_bfree, :uint64,
-            :f_blocks, :uint64,
-            :f_favail, :uint64,
-            :f_ffree, :uint64,
-            :f_files, :uint64,
-            :f_bsize, :ulong,
-            :f_flag, :ulong,
-            :f_frsize, :ulong,
-            :f_fsid, :ulong,
-            :f_namemax, :ulong
-          )
-        elsif /sunos|solaris/i.match?(RbConfig::CONFIG['host'])
-          layout(
-            :f_bsize, :ulong,
-            :f_frsize, :ulong,
-            :f_blocks, :uint64_t,
-            :f_bfree, :uint64_t,
-            :f_bavail, :uint64_t,
-            :f_files, :uint64_t,
-            :f_ffree, :uint64_t,
-            :f_favail, :uint64_t,
-            :f_fsid, :ulong,
-            :f_basetype, [:char, 16],
-            :f_flag, :ulong,
-            :f_namemax, :ulong,
-            :f_fstr, [:char, 32],
-            :f_filler, [:ulong, 16]
-          )
-        elsif /i686/i.match?(RbConfig::CONFIG['host'])
-          layout(
-            :f_bsize, :ulong,
-            :f_frsize, :ulong,
-            :f_blocks, :uint,
-            :f_bfree, :uint,
-            :f_bavail, :uint,
-            :f_files, :uint,
-            :f_ffree, :uint,
-            :f_favail, :uint,
-            :f_fsid, :ulong,
-            :f_flag, :ulong,
-            :f_namemax, :ulong,
-            :f_spare, [:int, 6]
-          )
-        else
-          layout(
-            :f_bsize, :ulong,
-            :f_frsize, :ulong,
-            :f_blocks, :uint64,
-            :f_bfree, :uint64,
-            :f_bavail, :uint64,
-            :f_files, :uint64,
-            :f_ffree, :uint64,
-            :f_favail, :uint64,
-            :f_fsid, :ulong,
-            :f_flag, :ulong,
-            :f_namemax, :ulong,
-            :f_spare, [:int, 6]
-          )
-        end
-      end
-    end
-  end
-end