facter 4.0.46 → 4.0.51

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

@@ -17,8 +17,7 @@ module Facter
     end
 
     def resolve_facts(user_query = [])
-      loaded_facts = @fact_loader.load(Options.get)
-      searched_facts = QueryParser.parse(user_query, loaded_facts)
+      searched_facts = parse_user_query(user_query)
 
       cache_manager = Facter::CacheManager.new
       searched_facts, cached_facts = cache_manager.resolve_facts(searched_facts)
@@ -32,6 +31,7 @@ module Facter
 
       FactFilter.new.filter_facts!(resolved_facts)
 
+      log_resolved_facts(resolved_facts)
       resolved_facts
     end
 
@@ -47,6 +47,12 @@ module Facter
 
     private
 
+    def parse_user_query(user_query)
+      loaded_facts = @fact_loader.load(Options.get)
+
+      QueryParser.parse(user_query, loaded_facts)
+    end
+
     def override_core_facts(core_facts, custom_facts)
       return core_facts unless custom_facts
 
@@ -60,5 +66,11 @@ module Facter
     def root_fact_name(fact)
       fact.name.split('.').first
     end
+
+    def log_resolved_facts(resolved_facts)
+      resolved_facts.each do |fact|
+        @log.debug("fact \"#{fact.name}\" has resolved to: #{fact.value}") unless fact.value.nil?
+      end
+    end
   end
 end

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

@@ -34,7 +34,11 @@ require 'facter/framework/config/fact_groups'
 
 load_dir(['config'])
 
-load_dir(%w[resolvers utils])
+load_dir(['util'])
+load_dir(%w[util resolvers])
+load_dir(%w[util facts])
+load_dir(%w[util resolvers networking])
+
 load_dir(['resolvers'])
 load_dir(['facts_utils'])
 load_dir(%w[framework core])
@@ -47,12 +51,12 @@ load_dir(%w[framework core fact external])
 load_dir(%w[framework formatters])
 
 os_hierarchy = OsDetector.instance.hierarchy
+os_hierarchy.each { |operating_system| load_dir(['util', operating_system.downcase, '**']) }
 os_hierarchy.each { |operating_system| load_dir(['facts', operating_system.downcase, '**']) }
 os_hierarchy.each { |operating_system| load_dir(['resolvers', operating_system.downcase, '**']) }
 
 require 'facter/custom_facts/core/legacy_facter'
 load_dir(%w[framework utils])
-load_dir(['util'])
 
 require 'facter/framework/core/fact_augmenter'
 require 'facter/framework/parsers/query_parser'

data/lib/facter/framework/core/options/option_store.rb

@@ -26,7 +26,7 @@ module Facter
     @config_file_external_dir = []
     @default_external_dir = []
     @fact_groups = {}
-    @sequential = false
+    @sequential = true
     @ttls = []
     @block_list = []
     @color = true
@@ -34,6 +34,8 @@ module Facter
     @timing = false
     @external_dir = []
     @custom_dir = []
+    @hocon = false
+    @allow_external_loggers = true
 
     class << self
       attr_reader :debug, :verbose, :log_level, :show_legacy,
@@ -42,7 +44,7 @@ module Facter
       attr_accessor :config, :user_query, :strict, :json,
                     :cache, :yaml, :puppet, :ttls, :block, :cli, :config_file_custom_dir,
                     :config_file_external_dir, :default_external_dir, :fact_groups,
-                    :block_list, :color, :trace, :sequential, :timing
+                    :block_list, :color, :trace, :sequential, :timing, :hocon, :allow_external_loggers
 
       attr_writer :external_dir
 
@@ -171,13 +173,13 @@ module Facter
         @ruby = true
         @user_query = []
         @json = false
+        @hocon = false
         @cache = true
         @yaml = false
         @puppet = false
         @ttls = []
         @block = true
         @cli = nil
-        @custom_facts = true
         reset_config
       end
 
@@ -192,10 +194,16 @@ module Facter
         @fact_groups = {}
         @block_list = {}
         @color = true
-        @sequential = false
+        @sequential = true
         @ttls = []
         @trace = false
         @timing = false
+        @allow_external_loggers = true
+        reset_facts
+      end
+
+      def reset_facts
+        @custom_facts = true
         @external_dir = []
         @custom_dir = []
       end

data/lib/facter/framework/detector/os_detector.rb

@@ -45,6 +45,7 @@ class OsDetector
     if hierarchy.empty?
       @log.debug("Could not detect hierarchy using os identifier: #{identifier} , trying with family")
 
+      # https://www.commandlinux.com/man-page/man5/os-release.5.html
       detect_family.to_s.split.each do |family|
         hierarchy = @os_hierarchy.construct_hierarchy(family)
         return hierarchy unless hierarchy.empty?
@@ -63,7 +64,14 @@ class OsDetector
     Facter::Resolvers::OsRelease.resolve(:id_like)
   end
 
+  def detect_based_on_release_file
+    @identifier = :devuan if File.readable?('/etc/devuan_version')
+  end
+
   def detect_distro
+    detect_based_on_release_file
+    return @identifier if @identifier
+
     [Facter::Resolvers::OsRelease,
      Facter::Resolvers::RedHatRelease,
      Facter::Resolvers::SuseRelease].each do |resolver|

data/lib/facter/framework/logging/logger.rb

@@ -60,7 +60,7 @@ module Facter
     def debug(msg)
       return unless debugging_active?
 
-      if @@message_callback
+      if @@message_callback && Options[:allow_external_loggers]
         @@message_callback.call(:debug, msg)
       else
         msg = colorize(msg, CYAN) if Options[:color]
@@ -71,7 +71,7 @@ module Facter
     def info(msg)
       if msg.nil? || msg.empty?
         empty_message_error(msg)
-      elsif @@message_callback
+      elsif @@message_callback && Options[:allow_external_loggers]
         @@message_callback.call(:info, msg)
       else
         msg = colorize(msg, GREEN) if Options[:color]
@@ -80,7 +80,7 @@ module Facter
     end
 
     def warn(msg)
-      if @@message_callback
+      if @@message_callback && Options[:allow_external_loggers]
         @@message_callback.call(:warn, msg)
       else
         msg = colorize(msg, YELLOW) if Options[:color]
@@ -91,7 +91,7 @@ module Facter
     def error(msg, colorize = false)
       @@has_errors = true
 
-      if @@message_callback
+      if @@message_callback && Options[:allow_external_loggers]
         @@message_callback.call(:error, msg)
       else
         msg = colorize(msg, RED) if colorize || Options[:color]
@@ -100,10 +100,10 @@ module Facter
     end
 
     def log_exception(exception)
-      msg = colorize(exception.message, RED) + "\n"
-      msg += exception.backtrace.join("\n") if Options[:trace]
+      msg = exception.message
+      msg += "\n" + exception.backtrace.join("\n") if Options[:trace]
 
-      @@logger.error(@class_name + ' - ' + msg)
+      error(msg, true)
     end
 
     private

data/lib/facter/models/fact_collection.rb

@@ -4,6 +4,7 @@ module Facter
   class FactCollection < Hash
     def initialize
       super
+      @log = Log.new(self)
     end
 
     def build_fact_collection!(facts)
@@ -39,7 +40,16 @@ module Facter
     private
 
     def bury_fact(fact)
-      bury(*fact.name.split('.') + fact.filter_tokens << fact.value)
+      split_fact_name = extract_fact_name(fact)
+      bury(*split_fact_name + fact.filter_tokens << fact.value)
+    rescue NoMethodError
+      @log.error("#{fact.type.to_s.capitalize} fact `#{fact.name}` cannot be added to collection."\
+          ' The format of this fact is incompatible with other'\
+          " facts that belong to `#{fact.name.split('.').first}` group")
+    end
+
+    def extract_fact_name(fact)
+      fact.type == :legacy ? [fact.name] : fact.name.split('.')
     end
   end
 end

data/lib/facter/models/loaded_fact.rb

@@ -3,13 +3,14 @@
 module Facter
   class LoadedFact
     attr_reader :name, :klass, :type
-    attr_accessor :file
+    attr_accessor :file, :is_env
 
     def initialize(name, klass, type = nil, file = nil)
       @name = name
       @klass = klass
       @type = type.nil? ? :core : type
       @file = file
+      @is_env = false
     end
   end
 end

data/lib/facter/resolvers/aio_agent_version.rb

@@ -8,12 +8,12 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_agent_version }
         end
 
         def read_agent_version
-          aio_agent_version = Util::FileHelper.safe_read('/opt/puppetlabs/puppet/VERSION', nil)&.chomp
+          aio_agent_version = Facter::Util::FileHelper.safe_read('/opt/puppetlabs/puppet/VERSION', nil)&.chomp
           aio_agent_version = aio_agent_version&.match(/^\d+\.\d+\.\d+(\.\d+){0,2}/)&.to_s
           @fact_list[:aio_agent_version] = aio_agent_version
         end

data/lib/facter/resolvers/aix/{architecture_resolver.rb → architecture.rb}

@@ -9,15 +9,15 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_architecture(fact_name) }
         end
 
         def read_architecture(fact_name)
-          require_relative 'utils/odm_query'
+          require 'facter/util/aix/odm_query'
 
           proc_number = read_proc
-          odmquery = ODMQuery.new
+          odmquery = Facter::Util::Aix::ODMQuery.new
           odmquery
             .equals('name', proc_number)
             .equals('attribute', 'type')
@@ -37,7 +37,7 @@ module Facter
         end
 
         def read_proc
-          odmquery = ODMQuery.new
+          odmquery = Facter::Util::Aix::ODMQuery.new
           odmquery
             .equals('PdDvLn', 'processor/sys/proc_rspc')
             .equals('status', '1')

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

@@ -9,7 +9,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { execute_lspv(fact_name) }
           end
 
@@ -34,7 +34,7 @@ module Facter
 
             return if stdout.empty?
 
-            info_size = InfoExtractor.extract(stdout, /PP SIZE:|TOTAL PPs:|FREE PPs:|PV STATE:/)
+            info_size = Facter::Util::Aix::InfoExtractor.extract(stdout, /PP SIZE:|TOTAL PPs:|FREE PPs:|PV STATE:/)
 
             return unless info_size['PV STATE']
 
@@ -42,7 +42,7 @@ module Facter
 
             {
               size_bytes: size_bytes,
-              size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
+              size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes)
             }
           end
 
@@ -50,9 +50,9 @@ module Facter
             physical_partitions = size_hash['TOTAL PPs'].to_i + size_hash['FREE PPs'].to_i
             size_physical_partition = size_hash['PP SIZE']
             exp = if size_physical_partition[/mega/]
-                    InfoExtractor::MEGABYTES_EXPONENT
+                    Facter::Util::Aix::InfoExtractor::MEGABYTES_EXPONENT
                   else
-                    InfoExtractor::GIGABYTES_EXPONENT
+                    Facter::Util::Aix::InfoExtractor::GIGABYTES_EXPONENT
                   end
             size_physical_partition.to_i * physical_partitions * exp
           end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      module FFI
+        RTM_IFINFO = 0xe
+        RTM_NEWADDR = 0xc
+
+        RTAX_DST = 0
+        RTAX_GATEWAY = 1
+        RTAX_NETMASK = 2
+        RTAX_GENMASK = 3
+        RTAX_IFP = 4
+        RTAX_IFA = 5
+        RTAX_AUTHOR = 6
+        RTAX_BRD = 7
+        RTAX_MAX = 8
+
+        RTA_DST = 0x1
+        RTA_GATEWAY = 0x2
+        RTA_NETMASK = 0x4
+        RTA_GENMASK = 0x8
+        RTA_IFP = 0x10
+        RTA_IFA = 0x20
+        RTA_AUTHOR = 0x40
+        RTA_BRD = 0x80
+        RTA_DOWNSTREAM = 0x100
+
+        AF_UNSPEC = 0
+        AF_INET = 2
+        AF_INET6 = 24
+        AF_MAX = 30
+
+        INET_ADDRSTRLEN = 16
+        INET6_ADDRSTRLEN = 46
+
+        RTAX_LIST = [
+          RTAX_DST,
+          RTAX_GATEWAY,
+          RTAX_NETMASK,
+          RTAX_GENMASK,
+          RTAX_IFP,
+          RTAX_IFA,
+          RTAX_AUTHOR,
+          RTAX_BRD
+        ].freeze
+
+        RTA_LIST = [
+          RTA_DST,
+          RTA_GATEWAY,
+          RTA_NETMASK,
+          RTA_GENMASK,
+          RTA_IFP,
+          RTA_IFA,
+          RTA_AUTHOR,
+          RTA_BRD,
+          RTA_DOWNSTREAM
+        ].freeze
+      end
+    end
+  end
+end

data/lib/facter/resolvers/aix/ffi/ffi_helper.rb

@@ -1,34 +1,160 @@
 # frozen_string_literal: true
 
 require 'ffi'
-
+require_relative 'structs'
+require_relative 'ffi'
 module Facter
-  module Aix
-    module FfiHelper
-      KINFO_GET_AVENRUN = 1
-      KINFO_READ        = 8 << 8
+  module Resolvers
+    module Aix
+      module FfiHelper
+        KINFO_GET_AVENRUN = 1
+        KINFO_READ        = 8 << 8
+        KINFO_RT          = 1 << 8
+        KINFO_RT_IFLIST   = KINFO_RT | 3
 
-      module Libc
-        extend FFI::Library
+        module Libc
+          extend ::FFI::Library
 
-        RTLD_LAZY   = 0x00000004
-        RTLD_GLOBAL = 0x00010000
-        RTLD_MEMBER = 0x00040000
+          RTLD_LAZY   = 0x00000004
+          RTLD_GLOBAL = 0x00010000
+          RTLD_MEMBER = 0x00040000
 
-        @ffi_lib_flags = RTLD_LAZY | RTLD_GLOBAL | RTLD_MEMBER
-        ffi_lib 'libc.a(shr.o)'
+          @ffi_lib_flags = RTLD_LAZY | RTLD_GLOBAL | RTLD_MEMBER
+          ffi_lib 'libc.a(shr.o)'
 
-        attach_function :getkerninfo, %i[int pointer pointer int], :int
-      end
+          attach_function :getkerninfo, %i[int pointer pointer int], :int
+          attach_function :inet_ntop, %i[int pointer pointer uint], :string
+        end
+
+        def self.read_load_averages
+          averages = ::FFI::MemoryPointer.new(:long_long, 3)
+          averages_size = ::FFI::MemoryPointer.new(:int, 1)
+          averages_size.write_int(averages.size)
+
+          return if Libc.getkerninfo(KINFO_READ | KINFO_GET_AVENRUN, averages, averages_size, 0).negative?
+
+          averages.read_array_of_long_long(3).map { |x| (x / 65_536.0).round(5) }
+        end
+
+        def self.read_interfaces
+          ksize = Libc.getkerninfo(KINFO_RT_IFLIST, nil, nil, 0)
+
+          log.debug('getkerninfo call was unsuccessful') if ksize.zero?
+
+          ksize_ptr = ::FFI::MemoryPointer.new(:int, ksize.size)
+          ksize_ptr.write_int(ksize)
+
+          result_ptr = ::FFI::MemoryPointer.new(:char, ksize)
+
+          res = Libc.getkerninfo(KINFO_RT_IFLIST, result_ptr, ksize_ptr, 0)
+          log.debug('getkerninfo call was unsuccessful') if res == -1
+
+          cursor = 0
+
+          interfaces = {}
+          while cursor < ksize_ptr.read_int
+            hdr = FFI::IfMsghdr.new(result_ptr + cursor)
+
+            case hdr[:ifm_type]
+            when FFI::RTM_IFINFO
+              link_addr = FFI::SockaddrDl.new(hdr.to_ptr + hdr.size)
+
+              interface_name = link_addr[:sdl_data].to_s[0, link_addr[:sdl_nlen]]
+              interfaces[interface_name] ||= {}
+
+            when FFI::RTM_NEWADDR
+              addresses = {}
+              addr_cursor = cursor + hdr.size
+              FFI::RTAX_LIST.each do |key|
+                xand = hdr[:ifm_addrs] & FFI::RTA_LIST[key]
+                next unless xand != 0
+
+                sockaddr = FFI::Sockaddr.new(result_ptr + addr_cursor)
+                addresses[key] = sockaddr
+                roundup_nr = roundup(sockaddr)
+                addr_cursor += roundup_nr
+              end
+
+              family = FFI::AF_UNSPEC
+
+              addresses.each do |_k, addr|
+                if family != FFI::AF_UNSPEC &&
+                   addr[:sa_family] != FFI::AF_UNSPEC &&
+                   family != addr[:sa_family]
+                  family = FFI::AF_MAX
+                  break
+                end
+                family = addr[:sa_family]
+              end
+
+              if addresses[FFI::RTAX_NETMASK][:sa_len]
+                addresses[FFI::RTAX_NETMASK][:sa_family] = family
+                netmask = address_to_string(addresses[FFI::RTAX_NETMASK])
+              end
+
+              address = address_to_string(addresses[FFI::RTAX_IFA]) if addresses[FFI::RTAX_IFA][:sa_len]
+
+              if addresses[FFI::RTAX_NETMASK][:sa_len] && addresses[FFI::RTAX_IFA][:sa_len]
+                network = address_to_string(addresses[FFI::RTAX_IFA], addresses[FFI::RTAX_NETMASK])
+              end
+
+              bindings = family == FFI::AF_INET ? :bindings : :bindings6
+              interfaces[interface_name][bindings] ||= []
+              interfaces[interface_name][bindings] << {
+                netmask: netmask.read_string,
+                address: address.read_string,
+                network: network.read_string
+              }
+            else
+              log.debug("got an unknown RT_IFLIST message: #{hdr[:ifm_type]}")
+            end
+
+            cursor += hdr[:ifm_msglen]
+          end
+
+          interfaces
+        end
+
+        def self.roundup(sockaddr)
+          if sockaddr[:sa_len].positive?
+            1 + ((sockaddr[:sa_len] - 1) | (1.size - 1))
+          else
+            1.size
+          end
+        end
+
+        def self.address_to_string(sockaddr, mask = nil)
+          if sockaddr[:sa_family] == FFI::AF_INET
+            in_addr_ip = FFI::SockaddrIn.new(sockaddr.to_ptr)
+
+            if mask && sockaddr[:sa_family] == mask[:sa_family]
+              in_addr_mask = FFI::SockaddrIn.new(mask.to_ptr)
+              in_addr_ip[:sin_addr][:s_addr] &= in_addr_mask[:sin_addr][:s_addr]
+            end
+
+            buffer = ::FFI::MemoryPointer.new(:char, FFI::INET_ADDRSTRLEN)
+            Libc.inet_ntop(FFI::AF_INET, in_addr_ip[:sin_addr].to_ptr, buffer, 16)
+
+            buffer
+          elsif sockaddr[:sa_family] == FFI::AF_INET6
+            in_addr_ip = FFI::SockaddrIn6.new(sockaddr.to_ptr)
+            if mask && sockaddr[:sa_family] == mask[:sa_family]
+              in_addr_mask = FFI::SockaddrIn6.new(sockaddr.to_ptr)
+              16.times do |i|
+                in_addr_ip[:sin6_addr][:u6_addr8][i] &= in_addr_mask[:sin6_addr][:u6_addr8][i]
+              end
+            end
 
-      def self.read_load_averages
-        averages = FFI::MemoryPointer.new(:long_long, 3)
-        averages_size = FFI::MemoryPointer.new(:int, 1)
-        averages_size.write_int(averages.size)
+            buffer = ::FFI::MemoryPointer.new(:char, FFI::INET6_ADDRSTRLEN)
+            Libc.inet_ntop(FFI::AF_INET6, in_addr_ip[:sin6_addr].to_ptr, buffer, 16)
 
-        return if Libc.getkerninfo(KINFO_READ | KINFO_GET_AVENRUN, averages, averages_size, 0).negative?
+            buffer
+          end
+        end
 
-        averages.read_array_of_long_long(3).map { |x| (x / 65_536.0).round(5) }
+        def self.log
+          @log ||= Log.new(self)
+        end
       end
     end
   end