facter 4.1.1 → 4.2.3

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/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

@@ -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
 
@@ -43,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
 
@@ -72,6 +72,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/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/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/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/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/ffi/kernel_ffi.rb

@@ -7,7 +7,7 @@ module KernelFFI
   extend FFI::Library
 
   ffi_convention :stdcall
-  ffi_lib [FFI::CURRENT_PROCESS, :ntdll]
+  ffi_lib :ntdll
   attach_function :RtlGetVersion, [:pointer], :int32
 
   STATUS_SUCCESS = 0

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