facter 4.2.0 → 4.2.4

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

@@ -137,11 +137,17 @@ module LegacyFacter
           if LegacyFacter.json?
             JSON.parse(content)
           else
-            LegacyFacter.warnonce "Cannot parse JSON data file #{filename} without the json library."
-            LegacyFacter.warnonce 'Suggested next step is `gem install json` to install the json library.'
+            log.warnonce "Cannot parse JSON data file #{filename} without the json library."
+            log.warnonce 'Suggested next step is `gem install json` to install the json library.'
             nil
           end
         end
+
+        private
+
+        def log
+          @log ||= Facter::Log.new(self)
+        end
       end
 
       register(JsonParser) do |filename|

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/framework/cli/cli.rb

@@ -97,6 +97,11 @@ module Facter
                  type: :boolean,
                  desc: 'Resolve facts sequentially'
 
+    class_option :puppet,
+                 type: :boolean,
+                 aliases: '-p',
+                 desc: 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
+
     desc '--man', 'Display manual.', hide: true
     map ['--man'] => :man
     def man(*args)
@@ -111,6 +116,7 @@ module Facter
 
     desc 'query', 'Default method', hide: true
     def query(*args)
+      Facter.puppet_facts if options[:puppet]
       output, status = Facter.to_user_output(@options, *args)
       puts output
 
@@ -126,7 +132,7 @@ module Facter
       Facter.values(@options, args)
     end
 
-    desc '--version, -v', 'Print the version', hide: true
+    desc '--version, -v', 'Print the version'
     map ['--version', '-v'] => :version
     def version(*_args)
       puts Facter::VERSION
@@ -156,19 +162,7 @@ module Facter
       puts cache_groups
     end
 
-    desc '--puppet, -p', 'Load the Puppet libraries, thus allowing Facter to load Puppet-specific facts.'
-    map ['--puppet', '-p'] => :puppet
-    def puppet(*args)
-      Facter.puppet_facts
-
-      output, status = Facter.to_user_output(@options, *args)
-      puts output
-
-      status = 1 if Facter::Log.errors?
-      exit status
-    end
-
-    desc 'help', 'Help for all arguments'
+    desc '--help, -h', 'Help for all arguments'
     def help(*args)
       help_string = +''
       help_string << help_header(args)
@@ -205,7 +199,11 @@ module Facter
         Cli.commands
            .select { |_k, command_class| command_class.instance_of?(Thor::Command) }
            .each do |_k, command|
-          help_command_options << build_option(command['name'], [], command['description'])
+          help_command_options << build_option(
+            command['name'],
+            [command['usage'].split(',')[1]],
+            command['description']
+          )
         end
 
         help_command_options

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}")
 
@@ -58,12 +60,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/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/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/ec2.rb

@@ -51,7 +51,7 @@ module Facter
 
         def get_data_from(url)
           headers = {}
-          headers['X-aws-ec2-metadata-token'] = Facter::Util::Resolvers::AwsToken.get if ENV['AWS_IMDSv2']
+          headers['X-aws-ec2-metadata-token'] = v2_token if v2_token
           Facter::Util::Resolvers::Http.get_request(url, headers, { session: determine_session_timeout })
         end
 
@@ -59,6 +59,13 @@ module Facter
           session_env = ENV['EC2_SESSION_TIMEOUT']
           session_env ? session_env.to_i : EC2_SESSION_TIMEOUT
         end
+
+        def v2_token
+          @v2_token ||= begin
+            token = Facter::Util::Resolvers::AwsToken.get
+            token == '' ? nil : token
+          end
+        end
       end
     end
   end

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