facter 4.1.1 → 4.2.0

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

@@ -1,21 +1,11 @@
 # frozen_string_literal: true
 
 module Facter
-  # Filter inside value of a fact.
-  # e.g. os.release.major is the user query, os.release is the fact
-  # and major is the filter criteria inside tha fact
   class FactFilter
-    def filter_facts!(searched_facts, user_query)
-      filter_legacy_facts!(searched_facts) if user_query.empty?
-      filter_blocked_legacy_facts!(searched_facts)
-
-      searched_facts.each do |fact|
-        fact.value = if fact.filter_tokens.any? && fact.value.respond_to?(:dig)
-                       fact.value.dig(*fact.filter_tokens)
-                     else
-                       fact.value
-                     end
-      end
+    def filter_facts!(resolved_facts, user_query)
+      filter_legacy_facts!(resolved_facts) if user_query.empty?
+      filter_blocked_legacy_facts!(resolved_facts)
+      resolved_facts
     end
 
     private

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/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.drop(query_token_range.size).map do |token|
-          token =~ /^[0-9]+$/ ? token.to_i : token
-        end
-      end
     end
   end
 end

data/lib/facter/models/fact_collection.rb

@@ -11,6 +11,12 @@ module Facter
       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?
@@ -23,15 +29,26 @@ module Facter
 
     def dig_fact(user_query)
       value(user_query)
-    rescue KeyError
+    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|
-          memo.fetch(key) { memo.fetch(key.to_s) } if memo.is_a?(Hash) || memo.is_a?(Array)
+          raise KeyError unless memo.respond_to?(:fetch)
+
+          memo.fetch(key) { memo.fetch(key.to_s) }
         end
       end
     end
@@ -60,7 +77,7 @@ module Facter
 
     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'\

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/linux/networking.rb

@@ -20,6 +20,7 @@ module Facter
             add_info_from_routing_table
             retrieve_primary_interface
             Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
+            add_flags
             @fact_list[fact_name]
           end
 
@@ -72,6 +73,23 @@ module Facter
             compare_ips(routes6, :bindings6)
           end
 
+          def add_flags
+            flags = Facter::Util::Linux::IfInet6.read_flags
+            flags.each_pair do |iface, ips|
+              next unless @fact_list[:interfaces].key?(iface)
+
+              ips.each_pair do |ip, ip_flags|
+                next unless @fact_list[:interfaces][iface].key?(:bindings6)
+
+                @fact_list[:interfaces][iface][:bindings6].each do |binding|
+                  next unless binding[:address] == ip
+
+                  binding[:flags] = ip_flags
+                end
+              end
+            end
+          end
+
           def compare_ips(routes, binding_key)
             routes.each do |route|
               next unless @fact_list[:interfaces].key?(route[:interface])

data/lib/facter/resolvers/mountpoints.rb

@@ -67,10 +67,24 @@ module Facter
         end
 
         def get_mount_sizes(mount)
-          stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(mount[:path])
+          begin
+            stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(mount[:path])
+            get_bytes_data(mount, stats)
+          rescue 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
+
+          populate_mount(mount)
+        end
 
-          get_bytes_data(mount, stats)
+        def get_bytes_data(mount, stats)
+          mount[:size_bytes] = stats.bytes_total.abs
+          mount[:available_bytes] = stats.bytes_available.abs
+          mount[:used_bytes] = stats.bytes_used.abs
+        end
 
+        def populate_mount(mount)
           total_bytes = mount[:used_bytes] + mount[:available_bytes]
           mount[:capacity] = Facter::Util::Resolvers::FilesystemHelper.compute_capacity(mount[:used_bytes], total_bytes)
 
@@ -78,12 +92,6 @@ module Facter
           mount[:available] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mount[:available_bytes])
           mount[:used] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mount[:used_bytes])
         end
-
-        def get_bytes_data(mount, stats)
-          mount[:size_bytes] = stats.bytes_total.abs
-          mount[:available_bytes] = stats.bytes_available.abs
-          mount[:used_bytes] = stats.bytes_used.abs
-        end
       end
     end
   end

data/lib/facter/resolvers/partitions.rb

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

data/lib/facter/resolvers/ruby.rb

@@ -13,7 +13,7 @@ module Facter
         end
 
         def retrieve_ruby_information(fact_name)
-          @fact_list[:sitedir] = RbConfig::CONFIG['sitelibdir']
+          @fact_list[:sitedir] = RbConfig::CONFIG['sitelibdir'] if RbConfig::CONFIG['sitedir']
           @fact_list[:platform] = RUBY_PLATFORM
           @fact_list[:version] = RUBY_VERSION
           @fact_list[fact_name]

data/lib/facter/resolvers/windows/ffi/identity_ffi.rb

@@ -12,4 +12,9 @@ module IdentityFFI
   ffi_convention :stdcall
   ffi_lib :shell32
   attach_function :IsUserAnAdmin, [], :win32_bool
+
+  def self.privileged?
+    result = self.IsUserAnAdmin()
+    result && result != FFI::WIN32FALSE
+  end
 end

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

@@ -31,12 +31,7 @@ module Facter
             return
           end
 
-          { user: name_ptr.read_wide_string_with_length(size_ptr.read_uint32), privileged: privileged? }
-        end
-
-        def privileged?
-          result = IdentityFFI::IsUserAnAdmin()
-          result && result != FFI::WIN32FALSE
+          { user: name_ptr.read_wide_string_with_length(size_ptr.read_uint32), privileged: IdentityFFI.privileged? }
         end
 
         def retrieve_facts(fact_name)

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

@@ -2,63 +2,65 @@
 
 module Facter
   module Resolvers
-    class Virtualization < BaseResolver
-      @log = Facter::Log.new(self)
+    module Windows
+      class Virtualization < BaseResolver
+        @log = Facter::Log.new(self)
 
-      init_resolver
+        init_resolver
 
-      class << self
-        # Virtual
-        # Is_Virtual
+        class << self
+          # Virtual
+          # Is_Virtual
 
-        MODEL_HASH = { 'VirtualBox' => 'virtualbox', 'VMware' => 'vmware', 'KVM' => 'kvm',
-                       'Bochs' => 'bochs', 'Google' => 'gce', 'OpenStack' => 'openstack' }.freeze
+          MODEL_HASH = { 'VirtualBox' => 'virtualbox', 'VMware' => 'vmware', 'KVM' => 'kvm',
+                         'Bochs' => 'bochs', 'Google' => 'gce', 'OpenStack' => 'openstack' }.freeze
 
-        private
+          private
 
-        def post_resolve(fact_name, _options)
-          @fact_list.fetch(fact_name) { read_fact_from_computer_system(fact_name) }
-        end
-
-        def read_fact_from_computer_system(fact_name)
-          win = Facter::Util::Windows::Win32Ole.new
-          comp = win.exec_query('SELECT Manufacturer,Model,OEMStringArray FROM Win32_ComputerSystem')
-          unless comp
-            @log.debug 'WMI query returned no results for Win32_ComputerSystem with values'\
-            ' Manufacturer, Model and OEMStringArray.'
-            return
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_fact_from_computer_system(fact_name) }
           end
 
-          build_fact_list(comp)
-          @fact_list[fact_name]
-        end
+          def read_fact_from_computer_system(fact_name)
+            win = Facter::Util::Windows::Win32Ole.new
+            comp = win.exec_query('SELECT Manufacturer,Model,OEMStringArray FROM Win32_ComputerSystem')
+            unless comp
+              @log.debug 'WMI query returned no results for Win32_ComputerSystem with values'\
+              ' Manufacturer, Model and OEMStringArray.'
+              return
+            end
 
-        def determine_hypervisor_by_model(comp)
-          MODEL_HASH[MODEL_HASH.keys.find { |key| comp.Model =~ /^#{key}/ }]
-        end
+            build_fact_list(comp)
+            @fact_list[fact_name]
+          end
 
-        def determine_hypervisor_by_manufacturer(comp)
-          manufacturer = comp.Manufacturer
-          if comp.Model =~ /^Virtual Machine/ && manufacturer =~ /^Microsoft/
-            'hyperv'
-          elsif manufacturer =~ /^Xen/
-            'xen'
-          elsif manufacturer =~ /^Amazon EC2/
-            'kvm'
-          else
-            'physical'
+          def determine_hypervisor_by_model(comp)
+            MODEL_HASH[MODEL_HASH.keys.find { |key| comp.Model =~ /^#{key}/ }]
+          end
+
+          def determine_hypervisor_by_manufacturer(comp)
+            manufacturer = comp.Manufacturer
+            if comp.Model =~ /^Virtual Machine/ && manufacturer =~ /^Microsoft/
+              'hyperv'
+            elsif manufacturer =~ /^Xen/
+              'xen'
+            elsif manufacturer =~ /^Amazon EC2/
+              'kvm'
+            else
+              'physical'
+            end
           end
-        end
 
-        def build_fact_list(comp)
-          @fact_list[:oem_strings] = []
-          @fact_list[:oem_strings] += comp.to_enum.map(&:OEMStringArray).flatten
+          def build_fact_list(comp)
+            @fact_list[:oem_strings] = []
+            @fact_list[:oem_strings] += comp.to_enum.map(&:OEMStringArray).flatten
 
-          comp = comp.to_enum.first
-          hypervisor = determine_hypervisor_by_model(comp) || determine_hypervisor_by_manufacturer(comp)
+            comp = comp.to_enum.first
+            hypervisor = determine_hypervisor_by_model(comp) || determine_hypervisor_by_manufacturer(comp)
 
-          @fact_list[:virtual] = hypervisor
-          @fact_list[:is_virtual] = hypervisor.include?('physical') ? false : true
+            @fact_list[:virtual] = hypervisor
+            @fact_list[:is_virtual] = hypervisor.include?('physical') ? false : true
+          end
         end
       end
     end

data/lib/facter/resolvers/xen.rb

@@ -56,7 +56,12 @@ module Facter
         end
 
         def find_command
-          return XEN_TOOLSTACK if File.exist?(XEN_TOOLSTACK)
+          num_stacks = 0
+          XEN_COMMANDS.each do |command|
+            num_stacks += 1 if File.exist?(command)
+          end
+
+          return XEN_TOOLSTACK if num_stacks > 1 && File.exist?(XEN_TOOLSTACK)
 
           XEN_COMMANDS.each { |command| return command if File.exist?(command) }
         end

data/lib/facter/util/facts/posix/virtual_detector.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    module Facts
+      module Posix
+        module VirtualDetector
+          class << self
+            def platform
+              @@fact_value ||= check_docker_lxc || check_freebsd || check_gce || retrieve_from_virt_what
+              @@fact_value ||= check_vmware || check_open_vz || check_vserver || check_xen || check_other_facts
+              @@fact_value ||= check_lspci || 'physical'
+
+              @@fact_value
+            end
+
+            private
+
+            def check_docker_lxc
+              Facter::Resolvers::Containers.resolve(:vm)
+            end
+
+            def check_gce
+              bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+              'gce' if bios_vendor&.include?('Google')
+            end
+
+            def check_vmware
+              Facter::Resolvers::Vmware.resolve(:vm)
+            end
+
+            def retrieve_from_virt_what
+              Facter::Resolvers::VirtWhat.resolve(:vm)
+            end
+
+            def check_open_vz
+              Facter::Resolvers::OpenVz.resolve(:vm)
+            end
+
+            def check_vserver
+              Facter::Resolvers::VirtWhat.resolve(:vserver)
+            end
+
+            def check_xen
+              Facter::Resolvers::Xen.resolve(:vm)
+            end
+
+            def check_freebsd
+              return unless Object.const_defined?('Facter::Resolvers::Freebsd::Virtual')
+
+              Facter::Resolvers::Freebsd::Virtual.resolve(:vm)
+            end
+
+            def check_other_facts
+              bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+              return 'kvm' if bios_vendor&.include?('Amazon EC2')
+
+              product_name = Facter::Resolvers::Linux::DmiBios.resolve(:product_name)
+              return unless product_name
+
+              Facter::Util::Facts::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+
+              nil
+            end
+
+            def check_lspci
+              Facter::Resolvers::Lspci.resolve(:vm)
+            end
+          end
+        end
+      end
+    end
+  end
+end