facter 4.0.51 → 4.2.1

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

@@ -37,6 +37,7 @@ load_dir(['config'])
 load_dir(['util'])
 load_dir(%w[util resolvers])
 load_dir(%w[util facts])
+load_dir(%w[util facts posix])
 load_dir(%w[util resolvers networking])
 
 load_dir(['resolvers'])
@@ -58,5 +59,4 @@ os_hierarchy.each { |operating_system| load_dir(['resolvers', operating_system.d
 require 'facter/custom_facts/core/legacy_facter'
 load_dir(%w[framework utils])
 
-require 'facter/framework/core/fact_augmenter'
 require 'facter/framework/parsers/query_parser'

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

@@ -41,10 +41,9 @@ module Facter
         store(ConfigFileOptions.get)
       end
 
-      def init_from_cli(cli_options = {}, user_query = nil)
+      def init_from_cli(cli_options = {})
         Facter::OptionStore.cli = true
         Facter::OptionStore.show_legacy = false
-        Facter::OptionStore.user_query = user_query
         Facter::OptionStore.trace = cli_options[:trace]
         OptionStore.set(:config, cli_options[:config])
         ConfigFileOptions.init(cli_options[:config])

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

@@ -18,6 +18,12 @@ module Facter
 
       private
 
+      def augment_structured_facts(global_conf)
+        return if !global_conf || global_conf['force-dot-resolution'].nil?
+
+        @options[:force_dot_resolution] = global_conf['force-dot-resolution']
+      end
+
       def augment_all
         augment_cli(Facter::ConfigReader.cli) if Options.cli?
         augment_globals
@@ -27,6 +33,7 @@ module Facter
       def augment_globals
         augment_ruby(Facter::ConfigReader.global)
 
+        augment_structured_facts(Facter::ConfigReader.global)
         augment_custom(Facter::ConfigReader.global)
         augment_external(Facter::ConfigReader.global)
         augment_show_legacy(Facter::ConfigReader.global)

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

@@ -13,7 +13,6 @@ module Facter
     @ruby = true
     @external_facts = true
     @config = nil
-    @user_query = []
     @strict = false
     @json = false
     @cache = true
@@ -36,14 +35,15 @@ module Facter
     @custom_dir = []
     @hocon = false
     @allow_external_loggers = true
+    @force_dot_resolution = false
 
     class << self
       attr_reader :debug, :verbose, :log_level, :show_legacy,
                   :custom_facts, :blocked_facts, :ruby, :external_facts
 
-      attr_accessor :config, :user_query, :strict, :json,
+      attr_accessor :config, :strict, :json,
                     :cache, :yaml, :puppet, :ttls, :block, :cli, :config_file_custom_dir,
-                    :config_file_external_dir, :default_external_dir, :fact_groups,
+                    :config_file_external_dir, :default_external_dir, :fact_groups, :force_dot_resolution,
                     :block_list, :color, :trace, :sequential, :timing, :hocon, :allow_external_loggers
 
       attr_writer :external_dir
@@ -171,7 +171,6 @@ module Facter
         @log_level = :warn
         @show_legacy = true
         @ruby = true
-        @user_query = []
         @json = false
         @hocon = false
         @cache = true
@@ -204,6 +203,7 @@ module Facter
 
       def reset_facts
         @custom_facts = true
+        @force_dot_resolution = false
         @external_dir = []
         @custom_dir = []
       end

data/lib/facter/framework/formatters/formatter_helper.rb

@@ -4,12 +4,11 @@ module Facter
   class FormatterHelper
     class << self
       def retrieve_facts_to_display_for_user_query(user_queries, resolved_facts)
-        facts_to_display = {}
+        facts_to_display = FactCollection.new
         user_queries.each do |user_query|
           fact_collection = build_fact_collection_for_user_query(user_query, resolved_facts)
 
-          splitted_user_query = Utils.split_user_query(user_query)
-          printable_value = fact_collection.dig(*splitted_user_query)
+          printable_value = fact_collection.dig_fact(user_query)
           facts_to_display.merge!(user_query => printable_value)
         end
 
@@ -24,8 +23,7 @@ module Facter
       def retrieve_fact_value_for_single_query(user_query, resolved_facts)
         fact_collection = build_fact_collection_for_user_query(user_query, resolved_facts)
         fact_collection = Utils.sort_hash_by_key(fact_collection)
-        splitted_user_query = Utils.split_user_query(user_query)
-        fact_collection.dig(*splitted_user_query)
+        fact_collection.dig_fact(user_query)
       end
 
       private

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

@@ -41,7 +41,7 @@ module Facter
       def no_user_query(loaded_facts)
         searched_facts = []
         loaded_facts.each do |loaded_fact|
-          searched_facts << SearchedFact.new(loaded_fact.name, loaded_fact.klass, [], '', loaded_fact.type)
+          searched_facts << SearchedFact.new(loaded_fact.name, loaded_fact.klass, '', loaded_fact.type)
         end
         searched_facts
       end
@@ -59,7 +59,7 @@ module Facter
           return resolvable_fact_list if resolvable_fact_list.any?
         end
 
-        resolvable_fact_list << SearchedFact.new(query, nil, [], query, :nil) if resolvable_fact_list.empty?
+        resolvable_fact_list << SearchedFact.new(query, nil, query, :nil) if resolvable_fact_list.empty?
 
         resolvable_fact_list
       end
@@ -73,7 +73,7 @@ module Facter
 
           next unless found_fact?(loaded_fact.name, query_fact)
 
-          searched_fact = construct_loaded_fact(query_tokens, query_token_range, loaded_fact)
+          searched_fact = construct_loaded_fact(query_tokens, loaded_fact)
           resolvable_fact_list << searched_fact
         end
 
@@ -93,23 +93,16 @@ module Facter
         true
       end
 
-      def construct_loaded_fact(query_tokens, query_token_range, loaded_fact)
-        filter_tokens = construct_filter_tokens(query_tokens, query_token_range)
+      def construct_loaded_fact(query_tokens, loaded_fact)
         user_query = @query_list.any? ? query_tokens.join('.') : ''
         fact_name = loaded_fact.name.to_s
         klass_name = loaded_fact.klass
         type = loaded_fact.type
-        sf = SearchedFact.new(fact_name, klass_name, filter_tokens, user_query, type)
+        sf = SearchedFact.new(fact_name, klass_name, user_query, type)
         sf.file = loaded_fact.file
 
         sf
       end
-
-      def construct_filter_tokens(query_tokens, query_token_range)
-        (query_tokens - query_tokens[query_token_range]).map do |token|
-          token =~ /^[0-9]+$/ ? token.to_i : token
-        end
-      end
     end
   end
 end

data/lib/facter/models/fact_collection.rb

@@ -7,6 +7,16 @@ module Facter
       @log = Log.new(self)
     end
 
+    def to_yaml
+      deep_to_h.to_yaml
+    end
+
+    # Transorms a list of {Facter::ResolvedFact} into a nested collection.
+    # @param facts [Array<Facter::ResolvedFact>]
+    #
+    # @return [FactCollection]
+    #
+    # @api private
     def build_fact_collection!(facts)
       facts.each do |fact|
         next if %i[core legacy].include?(fact.type) && fact.value.nil?
@@ -17,9 +27,29 @@ module Facter
       self
     end
 
-    def value(*keys)
-      keys.reduce(self) do |memo, key|
-        memo.fetch(key.to_s)
+    def dig_fact(user_query)
+      value(user_query)
+    rescue KeyError, TypeError
+      nil
+    end
+
+    # Collection#fetch implementation for nested collections.
+    # @param user_query [String] the search terms, separated by "."
+    #
+    # @return [String]
+    #
+    # @example for fact_collection = { "os": { "name": "Darwin" } }
+    #   fact_collection.fetch("os.name") #=> "Darwin"
+    #
+    # @api private
+    def value(user_query)
+      fetch(user_query) do
+        split_user_query = Facter::Utils.split_user_query(user_query)
+        split_user_query.reduce(self) do |memo, key|
+          raise KeyError unless memo.respond_to?(:fetch)
+
+          memo.fetch(key) { memo.fetch(key.to_s) }
+        end
       end
     end
 
@@ -39,9 +69,15 @@ module Facter
 
     private
 
+    def deep_to_h(collection = self)
+      collection.each_pair.with_object({}) do |(key, value), hash|
+        hash[key] = value.is_a?(FactCollection) ? deep_to_h(value) : value
+      end
+    end
+
     def bury_fact(fact)
       split_fact_name = extract_fact_name(fact)
-      bury(*split_fact_name + fact.filter_tokens << fact.value)
+      bury(*split_fact_name << 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'\
@@ -49,7 +85,14 @@ module Facter
     end
 
     def extract_fact_name(fact)
-      fact.type == :legacy ? [fact.name] : fact.name.split('.')
+      case fact.type
+      when :legacy
+        [fact.name]
+      when :custom, :external
+        Options[:force_dot_resolution] == true ? fact.name.split('.') : [fact.name]
+      else
+        fact.name.split('.')
+      end
     end
   end
 end

data/lib/facter/models/resolved_fact.rb

@@ -3,14 +3,13 @@
 module Facter
   class ResolvedFact
     attr_reader :name, :type
-    attr_accessor :user_query, :filter_tokens, :value, :file
+    attr_accessor :user_query, :value, :file
 
-    def initialize(name, value = '', type = :core, user_query = nil, filter_tokens = [])
+    def initialize(name, value = '', type = :core, user_query = nil)
       @name = name
       @value = Utils.deep_stringify_keys(value)
       @type = type
       @user_query = user_query
-      @filter_tokens = filter_tokens
     end
 
     def legacy?

data/lib/facter/models/searched_fact.rb

@@ -2,13 +2,12 @@
 
 module Facter
   class SearchedFact
-    attr_reader :name, :fact_class, :filter_tokens, :user_query, :type
+    attr_reader :name, :fact_class, :user_query, :type
     attr_accessor :file
 
-    def initialize(fact_name, fact_class, filter_tokens, user_query, type)
+    def initialize(fact_name, fact_class, user_query, type)
       @name = fact_name
       @fact_class = fact_class
-      @filter_tokens = filter_tokens
       @user_query = user_query
       @type = type
     end

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

@@ -33,7 +33,7 @@ module Facter
 
           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) }
+          averages.read_array_of_long_long(3).map { |x| (x / 65_536.0) }
         end
 
         def self.read_interfaces

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

@@ -16,6 +16,8 @@ module Facter
           def query_pddv(fact_name)
             @fact_list[:models] = []
             @fact_list[:logical_count] = 0
+            @fact_list[:cores_per_socket] = 0
+            @fact_list[:threads_per_core] = 0
 
             odmquery = Facter::Util::Aix::ODMQuery.new
             odmquery.equals('class', 'processor')
@@ -59,6 +61,8 @@ module Facter
             threads = smt_enabled ? smt_threads : 1
 
             @fact_list[:logical_count] += threads
+            @fact_list[:cores_per_socket] += 1
+            @fact_list[:threads_per_core] = threads
             @fact_list[:models].concat([type] * threads)
           end
 

data/lib/facter/resolvers/az.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Az < BaseResolver
+      init_resolver
+
+      AZ_METADATA_URL = 'http://169.254.169.254/metadata/instance?api-version=2020-09-01'
+      AZ_SESSION_TIMEOUT = 5
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          log.debug('Querying Az metadata')
+          @fact_list.fetch(fact_name) { read_facts(fact_name) }
+        end
+
+        def read_facts(fact_name)
+          @fact_list[:metadata] = {}
+          data = get_data_from(AZ_METADATA_URL)
+          @fact_list[:metadata] = JSON.parse(data) unless data.empty?
+
+          @fact_list[fact_name]
+        end
+
+        def get_data_from(url)
+          headers = { Metadata: 'true' }
+          Facter::Util::Resolvers::Http.get_request(url, headers, { session: determine_session_timeout })
+        end
+
+        def determine_session_timeout
+          session_env = ENV['AZ_SESSION_TIMEOUT']
+          session_env ? session_env.to_i : AZ_SESSION_TIMEOUT
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/base_resolver.rb

@@ -28,10 +28,10 @@ module Facter
           cache_nil_for_unresolved_facts(fact_name)
         end
       rescue NoMethodError => e
-        log.debug("Could not resolve #{fact_name}, got #{e}")
+        log.debug("Could not resolve #{fact_name}, got #{e} at #{e.backtrace[0]}")
         @fact_list[fact_name] = nil
       rescue LoadError, NameError => e
-        log.debug("resolving fact #{fact_name}, but #{e}")
+        log.debug("Resolving fact #{fact_name}, but got #{e} at #{e.backtrace[0]}")
         @fact_list[fact_name] = nil
       end
 

data/lib/facter/resolvers/dmi_decode.rb

@@ -37,7 +37,6 @@ module Facter
           @fact_list[:virtualbox_version] = output.match(/vboxVer_(\S+)/)&.captures&.first
           @fact_list[:virtualbox_revision] = output.match(/vboxRev_(\S+)/)&.captures&.first
           @fact_list[:vmware_version] = extract_vmware_version(output)
-          @fact_list[:vendor] = output.match(/Vendor: (\S+)/)&.captures&.first
 
           @fact_list[fact_name]
         end

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/hostname.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Hostname < BaseResolver
+        # :fqdn
+        # :domain
+        # :hostname
+
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
+          end
+
+          def retrieve_info(fact_name)
+            require 'socket'
+
+            output = retrieving_hostname
+            return nil unless output
+
+            # Check if the gethostname method retrieved fqdn
+            hostname, domain = parse_fqdn(output)
+
+            fqdn = retrieve_fqdn_for_host(hostname) if hostname_and_no_domain?(hostname, domain)
+
+            _, domain = parse_fqdn(fqdn) if exists_and_valid_fqdn?(fqdn, hostname)
+
+            domain = read_domain unless exists_and_not_empty?(domain)
+
+            construct_fact_list(hostname, domain, fqdn)
+            @fact_list[fact_name]
+          end
+
+          def retrieving_hostname
+            output = Socket.gethostname || ''
+            if output.empty? || output['0.0.0.0']
+              begin
+                require 'facter/util/resolvers/ffi/hostname'
+
+                output = Facter::Util::Resolvers::Ffi::Hostname.getffihostname
+              rescue LoadError => e
+                log.debug(e.message)
+                output = nil
+              end
+            end
+
+            log.debug("Tried to retrieve hostname and got: #{output}")
+            return output unless output&.empty?
+          end
+
+          def parse_fqdn(output)
+            if output =~ /(.*?)\.(.+$)/
+              log.debug("Managed to read hostname: #{Regexp.last_match(1)} and domain: #{Regexp.last_match(2)}")
+              [Regexp.last_match(1), Regexp.last_match(2)]
+            else
+              log.debug("Only managed to read hostname: #{output}, no domain was found.")
+              [output, '']
+            end
+          end
+
+          def retrieve_fqdn_for_host(host)
+            begin
+              name = Socket.getaddrinfo(host, 0, Socket::AF_UNSPEC, Socket::SOCK_STREAM, nil, Socket::AI_CANONNAME)[0]
+            rescue StandardError => e
+              log.debug("Socket.getaddrinfo failed to retrieve fqdn for hostname #{host} with: #{e}")
+            end
+
+            return name[2] if !name.nil? && !name.empty? && host != name[2] && name[2] != name[3]
+
+            retrieve_fqdn_for_host_with_ffi(host)
+          end
+
+          def retrieve_fqdn_for_host_with_ffi(host)
+            require 'facter/util/resolvers/ffi/hostname'
+
+            fqdn = Facter::Util::Resolvers::Ffi::Hostname.getffiaddrinfo(host)
+            log.debug("FFI getaddrinfo was called and it retrieved: #{fqdn}")
+            fqdn
+          rescue LoadError => e
+            log.debug(e.message)
+            nil
+          end
+
+          def exists_and_valid_fqdn?(fqdn, hostname)
+            exists_and_not_empty?(fqdn) && fqdn.start_with?("#{hostname}.")
+          end
+
+          def hostname_and_no_domain?(hostname, domain)
+            domain.empty? && !hostname.empty?
+          end
+
+          def read_domain
+            file_content = Facter::Util::FileHelper.safe_read('/etc/resolv.conf')
+            if file_content =~ /^domain\s+(\S+)/
+              Regexp.last_match(1)
+            elsif file_content =~ /^search\s+(\S+)/
+              Regexp.last_match(1)
+            end
+          end
+
+          def construct_fqdn(host, domain, fqdn)
+            return fqdn if exists_and_not_empty?(fqdn)
+            return if host.nil? || host.empty?
+
+            exists_and_not_empty?(domain) ? "#{host}.#{domain}" : host
+          end
+
+          def construct_fact_list(hostname, domain, fqdn)
+            @fact_list[:hostname] = hostname
+            @fact_list[:domain] = domain
+            @fact_list[:fqdn] = construct_fqdn(@fact_list[:hostname], @fact_list[:domain], fqdn)
+          end
+
+          def exists_and_not_empty?(variable)
+            variable && !variable.empty?
+          end
+        end
+      end
+    end
+  end
+end