facter 4.2.1 → 4.2.5

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

@@ -91,7 +91,7 @@ module Facter
           msg = "Already evaluated #{@name}"
           msg << " at #{@last_evaluated}" if msg.is_a? String
           msg << ', reevaluating anyways'
-          LegacyFacter.warn msg
+          log.warn msg
         end
 
         instance_eval(&block)
@@ -171,6 +171,10 @@ module Facter
 
       private
 
+      def log
+        @log ||= Facter::Log.new(self)
+      end
+
       # If the weights are equal, we consider external facts greater tan custom facts
       def compare_equal_weights(other)
         # Other is considered greater because self is custom fact and other is external

data/lib/facter/facts/windows/os/windows/display_version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facts
+  module Windows
+    module Os
+      module Windows
+        class DisplayVersion
+          FACT_NAME = 'os.windows.display_version'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::ProductRelease.resolve(:display_version)
+
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/framework/cli/cli.rb

@@ -97,6 +97,10 @@ module Facter
                  type: :boolean,
                  desc: 'Resolve facts sequentially'
 
+    class_option :http_debug,
+                 type: :boolean,
+                 desc: 'Whether to write HTTP request and responses to stderr. This should never be used in production.'
+
     class_option :puppet,
                  type: :boolean,
                  aliases: '-p',

data/lib/facter/framework/core/fact/internal/internal_fact_manager.rb

@@ -11,10 +11,8 @@ module Facter
     def resolve_facts(searched_facts)
       internal_searched_facts = filter_internal_facts(searched_facts)
       resolved_facts = if Options[:sequential]
-                         log.debug('Resolving facts sequentially')
                          resolve_sequentially(internal_searched_facts)
                        else
-                         log.debug('Resolving fact in parallel')
                          resolve_in_parallel(internal_searched_facts)
                        end
 

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

@@ -29,7 +29,6 @@ module Facter
     end
 
     def load_internal_facts(user_query, options)
-      @log.debug('Loading internal facts')
       internal_facts = []
       if user_query || options[:show_legacy]
         # if we have a user query, then we must search in core facts and legacy facts

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

@@ -13,6 +13,7 @@ module Facter
     end
 
     def resolve_facts(user_query = [])
+      log_resolving_method
       @options[:user_query] = user_query
       cache_manager = Facter::CacheManager.new
 
@@ -40,6 +41,7 @@ module Facter
     # - load all the core facts, external facts and env facts
     # - load all custom facts
     def resolve_fact(user_query)
+      log_resolving_method
       @options[:user_query] = user_query
       @log.debug("resolving fact with user_query: #{user_query}")
 
@@ -49,7 +51,9 @@ module Facter
       core_and_external_facts = core_or_external_fact(user_query) || []
       resolved_facts = core_and_external_facts + custom_facts
 
-      resolved_facts = all_custom_facts(user_query) if resolved_facts.empty?
+      if resolved_facts.empty? || resolved_facts.none? { |rf| rf.resolves?(user_query) }
+        resolved_facts.concat(all_custom_facts(user_query))
+      end
 
       @cache_manager.cache_facts(resolved_facts)
 
@@ -58,12 +62,21 @@ module Facter
     end
 
     def resolve_core(user_query = [], options = {})
+      log_resolving_method
       @cache_manager = CacheManager.new
       core_fact(user_query, options)
     end
 
     private
 
+    def log_resolving_method
+      if Options[:sequential]
+        @log.debugonce('Resolving facts sequentially')
+      else
+        @log.debugonce('Resolving fact in parallel')
+      end
+    end
+
     def core_fact(user_query, options)
       loaded_facts_hash = @fact_loader.load_internal_facts(user_query, options)
 

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

@@ -36,6 +36,7 @@ module Facter
     @hocon = false
     @allow_external_loggers = true
     @force_dot_resolution = false
+    @http_debug = false
 
     class << self
       attr_reader :debug, :verbose, :log_level, :show_legacy,
@@ -44,7 +45,7 @@ module Facter
       attr_accessor :config, :strict, :json,
                     :cache, :yaml, :puppet, :ttls, :block, :cli, :config_file_custom_dir,
                     :config_file_external_dir, :default_external_dir, :fact_groups, :force_dot_resolution,
-                    :block_list, :color, :trace, :sequential, :timing, :hocon, :allow_external_loggers
+                    :block_list, :color, :trace, :sequential, :timing, :hocon, :allow_external_loggers, :http_debug
 
       attr_writer :external_dir
 
@@ -179,6 +180,7 @@ module Facter
         @ttls = []
         @block = true
         @cli = nil
+        @http_debug = false
         reset_config
       end
 

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

@@ -15,8 +15,16 @@ module Facter
     @@logger = nil
     @@message_callback = nil
     @@has_errors = false
+    @@debug_messages = []
+    @@warn_messages = []
+    @@timing = false
 
     class << self
+      def clear_messages
+        @@debug_messages.clear
+        @@warn_messages.clear
+      end
+
       def on_message(&block)
         @@message_callback = block
       end
@@ -47,6 +55,41 @@ module Facter
           "[#{datetime}] #{severity} #{msg} \n"
         end
       end
+
+      # Print an exception message, and optionally a backtrace if trace is set
+
+      # Print timing information
+      #
+      # @param string [String] the time to print
+      # @return [void]
+      #
+      # @api private
+      def show_time(string)
+        return unless string && timing?
+
+        if @@message_callback
+          @@message_callback.call(:info, string)
+        else
+          warn("#{GREEN}#{string}#{RESET}")
+        end
+      end
+
+      # Enable or disable logging of timing information
+      #
+      # @param bool [true, false]
+      # @return [void]
+      #
+      # @api private
+      def timing(bool)
+        @@timing = bool
+      end
+
+      # Returns whether timing output is turned on
+      #
+      # @api private
+      def timing?
+        @@timing
+      end
     end
 
     def initialize(logged_class)
@@ -68,6 +111,16 @@ module Facter
       end
     end
 
+    def debugonce(msg)
+      return unless debugging_active?
+
+      message_string = msg.to_s
+      return if @@debug_messages.include? message_string
+
+      @@debug_messages << message_string
+      debug(message_string)
+    end
+
     def info(msg)
       if msg.nil? || msg.empty?
         empty_message_error(msg)
@@ -88,6 +141,14 @@ module Facter
       end
     end
 
+    def warnonce(message)
+      message_string = message.to_s
+      return if @@warn_messages.include? message_string
+
+      @@warn_messages << message_string
+      warn(message_string)
+    end
+
     def error(msg, colorize = false)
       @@has_errors = true
 

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

@@ -24,13 +24,11 @@ module Facter
       # Returns a list of SearchedFact objects that resolve the users query.
       def parse(query_list, loaded_fact)
         matched_facts = []
-        @log.debug "User query is: #{query_list}"
         @query_list = query_list
 
         return no_user_query(loaded_fact) unless query_list.any?
 
         query_list.each do |query|
-          @log.debug "Query is #{query}"
           found_facts = search_for_facts(query, loaded_fact)
           matched_facts << found_facts
         end
@@ -65,7 +63,6 @@ module Facter
       end
 
       def get_facts_matching_tokens(query_tokens, query_token_range, loaded_fact_hash)
-        @log.debug "Checking query tokens #{query_tokens[query_token_range].join('.')}"
         resolvable_fact_list = []
 
         loaded_fact_hash.each do |loaded_fact|
@@ -77,7 +74,7 @@ module Facter
           resolvable_fact_list << searched_fact
         end
 
-        @log.debug "List of resolvable facts: #{resolvable_fact_list.inspect}"
+        @log.debug "List of resolvable facts: #{resolvable_fact_list.inspect}" if resolvable_fact_list.any?
         resolvable_fact_list
       end
 

data/lib/facter/models/resolved_fact.rb

@@ -23,5 +23,9 @@ module Facter
     def to_s
       @value.to_s
     end
+
+    def resolves?(user_query)
+      @name == user_query
+    end
   end
 end

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

@@ -34,7 +34,7 @@ module Facter
 
             return if stdout.empty?
 
-            info_size = Facter::Util::Aix::InfoExtractor.extract(stdout, /PP SIZE:|TOTAL PPs:|FREE PPs:|PV STATE:/)
+            info_size = Facter::Util::Aix::InfoExtractor.extract(stdout, :lspv)
 
             return unless info_size['PV STATE']
 

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

@@ -19,7 +19,7 @@ module Facter
             @fact_list[:mountpoints] = {}
             output = Facter::Core::Execution.execute('mount', logger: log)
             output.split("\n").map do |line|
-              next if line =~ /node|---|procfs|ahafs/
+              next if line =~ /\s+node\s+|---|procfs|ahafs/
 
               elem = line.split("\s")
 

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

@@ -40,7 +40,7 @@ module Facter
 
             return if stdout.empty?
 
-            info_hash =  Facter::Util::Aix::InfoExtractor.extract(stdout, /PPs:|PP SIZE|TYPE:|LABEL:|MOUNT/)
+            info_hash =  Facter::Util::Aix::InfoExtractor.extract(stdout, :lslv)
             size_bytes = compute_size(info_hash)
 
             part_info = {

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

@@ -42,8 +42,9 @@ module Facter
             return unless result
 
             names = retrieve_from_array(result.scan(/name\s=\s.*/), 1)
+            status = retrieve_from_array(result.scan(/\s+status\s=\s.*/), 1)
 
-            names.each { |elem| query_cuat(elem) }
+            names.each_with_index { |elem, idx| query_cuat(elem) if status[idx] == '1' }
           end
 
           def query_cuat(name)

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

@@ -44,7 +44,6 @@ module Facter
 
               parse_ip_command_line(line, mtu_and_indexes)
             end
-            log.debug("Associated MTU and index in ip command: #{mtu_and_indexes}")
             mtu_and_indexes
           end
 

data/lib/facter/resolvers/lsb_release.rb

@@ -25,8 +25,7 @@ module Facter
         end
 
         def lsb_release_installed?
-          output = Facter::Core::Execution.execute('which lsb_release', logger: log)
-          @fact_list[:lsb_release_installed] = !output.empty?
+          @fact_list[:lsb_release_installed] = !Facter::Core::Execution.which('lsb_release').nil?
         end
 
         def read_lsb_release_file

data/lib/facter/resolvers/macosx/{processor.rb → processors.rb}

@@ -29,42 +29,42 @@ module Facter
 
           def read_processor_data(fact_name)
             output = Facter::Core::Execution.execute("sysctl #{ITEMS.values.join(' ')}", logger: log)
-            build_fact_list(output.split("\n"))
+            processors_hash = Hash[*output.split("\n").collect { |v| [v.split(': ')[0], v.split(': ')[1]] }.flatten]
+            build_fact_list(processors_hash)
             @fact_list[fact_name]
           end
 
-          def build_fact_list(processors_data)
-            build_logical_count(processors_data[0])
-            build_physical_count(processors_data[1])
-            build_models(processors_data[2])
-            build_speed(processors_data[3])
-            build_cores_per_socket(processors_data[4])
-            build_threads_per_core(processors_data[5], processors_data[4])
+          def build_fact_list(hash)
+            build_logical_count(hash)
+            build_physical_count(hash)
+            build_models(hash)
+            build_speed(hash)
+            build_cores_per_socket(hash)
+            build_threads_per_core(hash)
           end
 
-          def build_logical_count(count)
-            @fact_list[:logicalcount] = count.split(': ')[1].to_i
+          def build_logical_count(hash)
+            @fact_list[:logicalcount] = hash[ITEMS[:logical_count]].to_i
           end
 
-          def build_physical_count(count)
-            @fact_list[:physicalcount] = count.split(': ')[1].to_i
+          def build_physical_count(hash)
+            @fact_list[:physicalcount] = hash[ITEMS[:physical_count]].to_i
           end
 
-          def build_models(model)
-            brand = model.split(': ').fetch(1)
-            @fact_list[:models] = Array.new(@fact_list[:logicalcount].to_i, brand)
+          def build_models(hash)
+            @fact_list[:models] = Array.new(@fact_list[:logicalcount].to_i, hash[ITEMS[:brand]])
           end
 
-          def build_speed(value)
-            @fact_list[:speed] = value.split(': ')[1].to_i
+          def build_speed(hash)
+            @fact_list[:speed] = hash[ITEMS[:speed]].to_i
           end
 
-          def build_cores_per_socket(count)
-            @fact_list[:cores_per_socket] = count.split(': ')[1].to_i
+          def build_cores_per_socket(hash)
+            @fact_list[:cores_per_socket] = hash[ITEMS[:cores_per_socket]].to_i
           end
 
-          def build_threads_per_core(number_of_threads, number_of_cores)
-            @fact_list[:threads_per_core] = number_of_threads.split(': ')[1].to_i / number_of_cores.split(': ')[1].to_i
+          def build_threads_per_core(hash)
+            @fact_list[:threads_per_core] = hash[ITEMS[:threads_per_core]].to_i / hash[ITEMS[:cores_per_socket]].to_i
           end
         end
       end

data/lib/facter/resolvers/networking.rb

@@ -37,7 +37,9 @@ module Facter
 
         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')
+          # convert ip6 ranges into single ip. eg. 2001:db8:cafe::132:213 -->
+          # 2001:db8:cafe::132:213 is converted to 2001:db8:cafe::132:213
+          response.gsub!(/([\da-fA-F]+([\.:]+[\da-fA-F]+)*)\s+-->\s+[\da-fA-F]+([\.:]+[\da-fA-F]+)*/, '\\1')
         end
 
         def parse_interfaces_response(response)

data/lib/facter/resolvers/os_release.rb

@@ -53,12 +53,15 @@ module Facter
         end
 
         def process_name
-          return unless @fact_list[:name]
+          os_name = @fact_list[:name]
+          return unless os_name
 
-          @fact_list[:name] = if @fact_list[:name].downcase.start_with?('red', 'oracle')
-                                @fact_list[:name].split(' ')[0..1].join
+          @fact_list[:name] = if os_name.downcase.start_with?('red', 'oracle', 'arch', 'manjaro')
+                                os_name = os_name.split(' ')[0..1].join
+                                os_name = os_name.capitalize if os_name.downcase.start_with?('arch', 'manjaro')
+                                os_name
                               else
-                                @fact_list[:name].split(' ')[0].strip
+                                os_name.split(' ')[0].strip
                               end
         end
 

data/lib/facter/resolvers/partitions.rb

@@ -107,9 +107,7 @@ module Facter
 
           return blkid_and_lsblk[command_exists_key] unless blkid_and_lsblk[command_exists_key].nil?
 
-          output = Facter::Core::Execution.execute("which #{command}", logger: log)
-
-          blkid_and_lsblk[command_exists_key] = !output.empty?
+          blkid_and_lsblk[command_exists_key] = !Facter::Core::Execution.which(command).nil?
         end
 
         def execute_and_extract_blkid_info

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

@@ -24,10 +24,19 @@ module Facter
 
         def build_fact_list(reg)
           reg.each do |name, _value|
-            @fact_list[:edition_id] = reg[name] if name == 'EditionID'
-            @fact_list[:installation_type] = reg[name] if name == 'InstallationType'
-            @fact_list[:product_name] = reg[name] if name == 'ProductName'
-            @fact_list[:release_id] = reg[name] if name == 'ReleaseId'
+            case name
+            when 'EditionID'
+              @fact_list[:edition_id] = reg[name]
+            when 'InstallationType'
+              @fact_list[:installation_type] = reg[name]
+            when 'ProductName'
+              @fact_list[:product_name] = reg[name]
+            when 'DisplayVersion'
+              @fact_list[:release_id] = reg[name]
+              @fact_list[:display_version] = reg[name]
+            when 'ReleaseId'
+              @fact_list[:release_id] = reg[name] unless @fact_list[:release_id]
+            end
           end
         end
       end

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

@@ -6,17 +6,68 @@ module Facter
       module InfoExtractor
         MEGABYTES_EXPONENT = 1024**2
         GIGABYTES_EXPONENT = 1024**3
+        PROPERTIES = {
+          lslv: [
+            'LOGICAL VOLUME:',
+            'VOLUME GROUP:',
+            'LV IDENTIFIER:',
+            'PERMISSION:',
+            'VG STATE:',
+            'LV STATE:',
+            'TYPE:',
+            'WRITE VERIFY:',
+            'MAX LPs:',
+            'PP SIZE:',
+            'COPIES:',
+            'SCHED POLICY:',
+            'LPs:',
+            'PPs:',
+            'STALE PPs:',
+            'BB POLICY:',
+            'INTER-POLICY:',
+            'RELOCATABLE:',
+            'INTRA-POLICY:',
+            'UPPER BOUND:',
+            'MOUNT POINT:',
+            'LABEL:',
+            'MIRROR WRITE CONSISTENCY:',
+            'EACH LP COPY ON A SEPARATE PV ?:',
+            'Serialize IO ?:'
+          ],
+          lspv: [
+            'PHYSICAL VOLUME:',
+            'VOLUME GROUP:',
+            'PV IDENTIFIER:',
+            'VG IDENTIFIER',
+            'PV STATE:',
+            'STALE PARTITIONS:',
+            'ALLOCATABLE:',
+            'PP SIZE:',
+            'LOGICAL VOLUMES:',
+            'TOTAL PPs:',
+            'VG DESCRIPTORS:',
+            'FREE PPs:',
+            'HOT SPARE:',
+            'USED PPs:',
+            'MAX REQUEST:',
+            'FREE DISTRIBUTION:',
+            'USED DISTRIBUTION:',
+            'MIRROR POOL:'
+          ]
+        }.freeze
 
-        def self.extract(content, regex)
-          content = content.each_line.map do |line|
-            next unless regex =~ line
-
-            line.split(/:\s*|\s{2,}/)
+        def self.extract(content, cmd)
+          property_hash = {}
+          properties = PROPERTIES[cmd]
+          properties.each do |property|
+            str = (properties - [property]).join('|')
+            matcher = content.match(/#{Regexp.escape(property)}([^\n]*?)(#{str}|\n|$)/s)
+            if matcher
+              value = matcher[1].strip
+              property_hash[property.split(':').first] = value
+            end
           end
-
-          content.flatten!.reject!(&:nil?)
-
-          Hash[*content]
+          property_hash
         end
       end
     end

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

@@ -23,9 +23,11 @@ module Facter
           private
 
           def check_version_10(consumerrel, kernel_version)
+            return '10' if consumerrel
+
             build_number = kernel_version[/([^.]*)$/].to_i
-            if consumerrel
-              '10'
+            if build_number >= 20_348
+              '2022'
             elsif build_number >= 17_623
               '2019'
             else

data/lib/facter/util/linux/dhcp.rb

@@ -75,7 +75,10 @@ module Facter
           def search_with_dhcpcd_command(interface_name)
             @log.debug("Attempt to get DHCP for interface #{interface_name}, from dhcpcd command")
 
-            output = Facter::Core::Execution.execute("dhcpcd -U #{interface_name}", logger: @log)
+            @dhcpcd_command ||= Facter::Core::Execution.which('dhcpcd')
+            return unless @dhcpcd_command
+
+            output = Facter::Core::Execution.execute("#{@dhcpcd_command} -U #{interface_name}", logger: @log)
             dhcp = output.match(/dhcp_server_identifier='(.*)'/)
             dhcp[1] if dhcp
           end

data/lib/facter/util/linux/socket_parser.rb

@@ -59,8 +59,23 @@ module Facter
           end
 
           def bond_master_of(interface_name)
-            content = Facter::Core::Execution.execute("ip link show #{interface_name}", logger: @log)
-            content.match(/master (\S*) /)&.captures&.first
+            content = get_ip_link_show_data(interface_name)
+            content&.match(/master (\S*) /)&.captures&.first
+          end
+
+          def get_ip_link_show_data(interface_name)
+            @ip_link_show_data ||= read_ip_link_show_data
+            @ip_link_show_data[interface_name]
+          end
+
+          def read_ip_link_show_data
+            ip_link_show_data = {}
+            output = Facter::Core::Execution.execute('ip -o link show', logger: @log)
+            output.each_line do |line|
+              interface_name = line.split(':')[1]&.strip if line
+              ip_link_show_data[interface_name] = line if interface_name
+            end
+            ip_link_show_data
           end
 
           def mac_from(ifaddr)

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

@@ -60,6 +60,9 @@ module Facter
             http = Net::HTTP.new(parsed_url.host)
             http.read_timeout = timeouts[:session] || SESSION_TIMEOUT
             http.open_timeout = timeouts[:connection] || CONNECTION_TIMEOUT
+
+            http.set_debug_output($stderr) if Options[:http_debug]
+
             http
           end
 

data/lib/facter/version.rb

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