facter 4.0.52 → 4.2.2

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

@@ -19,7 +19,6 @@ module Facter
 
           def retrieve_info(fact_name)
             require 'socket'
-            require 'facter/util/resolvers/ffi/hostname'
 
             output = retrieving_hostname
             return nil unless output
@@ -38,13 +37,20 @@ module Facter
           end
 
           def retrieving_hostname
-            output = Socket.gethostname
-            if !output || output.empty? || output['0.0.0.0']
-              output = Facter::Util::Resolvers::Ffi::Hostname.getffihostname
+            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}")
-            output && !output.empty? ? output : nil
+            return output unless output&.empty?
           end
 
           def parse_fqdn(output)
@@ -70,9 +76,14 @@ module Facter
           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)

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/macosx/mountpoints.rb

@@ -21,7 +21,7 @@ module Facter
               device = fs.name
               filesystem = fs.mount_type
               path = fs.mount_point
-              options = fs.options.split(',').map(&:strip).map { |o| o == 'rootfs' ? 'root' : o }
+              options = read_options(fs.options)
 
               mounts[path] = read_stats(path).tap do |hash|
                 hash[:device] = device
@@ -53,6 +53,19 @@ module Facter
               used: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(used_bytes)
             }
           end
+
+          def read_options(options)
+            options_map = {
+              'read-only' => 'readonly',
+              'asynchronous' => 'async',
+              'synchronous' => 'noasync',
+              'quotas' => 'quota',
+              'rootfs' => 'root',
+              'defwrite' => 'deferwrites'
+            }
+
+            options.split(',').map(&:strip).map { |o| options_map.key?(o) ? options_map[o] : o }
+          end
         end
       end
     end

data/lib/facter/resolvers/macosx/processor.rb

@@ -9,12 +9,17 @@ module Facter
         ITEMS = { logical_count: 'hw.logicalcpu_max',
                   physical_count: 'hw.physicalcpu_max',
                   brand: 'machdep.cpu.brand_string',
-                  speed: 'hw.cpufrequency_max' }.freeze
+                  speed: 'hw.cpufrequency_max',
+                  cores_per_socket: 'machdep.cpu.core_count',
+                  threads_per_core: 'machdep.cpu.thread_count' }.freeze
+
         class << self
           # :logicalcount
           # :models
           # :physicalcount
           # :speed
+          # :cores_per_socket
+          # :threads_per_core
 
           private
 
@@ -33,6 +38,8 @@ module Facter
             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])
           end
 
           def build_logical_count(count)
@@ -51,6 +58,14 @@ module Facter
           def build_speed(value)
             @fact_list[:speed] = value.split(': ')[1].to_i
           end
+
+          def build_cores_per_socket(count)
+            @fact_list[:cores_per_socket] = count.split(': ')[1].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
+          end
         end
       end
     end

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,12 +37,14 @@ 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)
           parsed_interfaces_data = {}
-          interfaces_data = Hash[*response.split(/^([A-Za-z0-9_]+): /)[1..-1]]
+          interfaces_data = Hash[*response.split(/^([A-Za-z0-9_\.]+): /)[1..-1]]
 
           interfaces_data.each do |interface_name, raw_data|
             parsed_interface_data = {}
@@ -63,7 +65,8 @@ module Facter
         end
 
         def extract_mac(raw_data, parsed_interface_data)
-          mac = raw_data.match(/(?:ether|lladdr)\s+(\w?\w:\w?\w:\w?\w:\w?\w:\w?\w:\w?\w)/)&.captures&.first
+          mac = raw_data.match(/(?:ether|lladdr)\s+((?:\w?\w:){5}\w?\w)|(?:infiniband)\s+((?:\w?\w:){19}\w?\w)/)
+                       &.captures&.compact&.first
           parsed_interface_data[:mac] = mac unless mac.nil?
         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/processors_lscpu.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Lscpu < BaseResolver
+        init_resolver
+
+        ITEMS = { threads_per_core: "-e 'Thread(s)'",
+                  cores_per_socket: "-e 'Core(s)'" }.freeze
+
+        class << self
+          #:cores_per_socket
+          #:threads_per_core
+
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_cpuinfo(fact_name) }
+          end
+
+          def read_cpuinfo(fact_name)
+            lscpu_output = Facter::Core::Execution.execute("lscpu | grep #{ITEMS.values.join(' ')}", logger: log)
+            build_fact_list(lscpu_output.split("\n"))
+            @fact_list[fact_name]
+          end
+
+          def build_fact_list(processors_data)
+            build_threads_per_core(processors_data[0])
+            build_cores_per_socket(processors_data[1])
+          end
+
+          def build_threads_per_core(index)
+            @fact_list[:threads_per_core] = index.split(': ')[1].to_i
+          end
+
+          def build_cores_per_socket(index)
+            @fact_list[:cores_per_socket] = index.split(': ')[1].to_i
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,21 +13,21 @@ module Facter
         end
 
         def retrieve_facts(fact_name)
-          mountpoint = read_mounts_file if @fact_list[:enabled].nil?
+          mountpoint = selinux_mountpoint
+
+          @fact_list[:enabled] = !mountpoint.empty? && read_selinux_config
           read_other_selinux_facts(mountpoint) if @fact_list[:enabled]
 
           @fact_list[fact_name]
         end
 
-        def read_mounts_file
+        def selinux_mountpoint
           output = Facter::Core::Execution.execute('cat /proc/self/mounts', logger: log)
-          @fact_list[:enabled] = false
           mountpoint = ''
 
           output.each_line do |line|
             next unless line =~ /selinuxfs/
 
-            @fact_list[:enabled] = true
             mountpoint = line.split("\s")[1]
             break
           end
@@ -35,8 +35,6 @@ module Facter
         end
 
         def read_other_selinux_facts(mountpoint)
-          return unless read_selinux_config
-
           enforce_file = "#{mountpoint}/enforce"
           policy_file = "#{mountpoint}/policyvers"
 
@@ -60,7 +58,7 @@ module Facter
             @fact_list[:config_policy] = line.split('=').last.strip if line =~ /^SELINUXTYPE=/
           end
 
-          true unless file_lines.empty?
+          !file_lines.empty? ? true : false
         end
       end
     end

data/lib/facter/resolvers/solaris/ffi/structs.rb

@@ -111,6 +111,18 @@ module Facter
             self[:sin_addr][:s_addr]
           end
         end
+
+        class In6Addr < ::FFI::Struct
+          layout :s_addr, [:uint32_t, 4]
+        end
+
+        class SockaddrIn6 < ::FFI::Struct
+          layout  :sin6_family, :sa_family_t,
+                  :sin6_port, :in_port_t,
+                  :sin6_flowinfo, :uint32_t,
+                  :sin6_addr, In6Addr,
+                  :sin6_scope_id, :uint32_t
+        end
       end
     end
   end

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

@@ -14,23 +14,26 @@ module Facter
             @fact_list.fetch(fact_name) { read_mounts(fact_name) }
           end
 
-          def root_device
-            cmdline = Facter::Util::FileHelper.safe_read('/proc/cmdline')
-            match = cmdline.match(/root=([^\s]+)/)
-            match&.captures&.first
-          end
-
-          def compute_device(device)
-            # If the "root" device, lookup the actual device from the kernel options
-            # This is done because not all systems symlink /dev/root
-            device = root_device if device == '/dev/root'
-            device
+          def exclude_auto_home_mounts!
+            @mounts.reject! do |mount|
+              parent = mount[:path].rpartition('/').first
+              @auto_home_paths.include?(parent)
+            end
           end
 
           def read_mounts(fact_name) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-            mounts = []
+            @mounts = []
+            @auto_home_paths = []
+
             Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |fs|
-              device = compute_device(fs.name)
+              if fs.name == 'auto_home'
+                @auto_home_paths << fs.mount_point
+                next
+              end
+
+              next if fs.mount_type == 'autofs'
+
+              device = fs.name
               filesystem = fs.mount_type
               path = fs.mount_point
               options = fs.options.split(',').map(&:strip)
@@ -47,11 +50,14 @@ module Facter
               available = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(available_bytes)
               used = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(used_bytes)
 
-              mounts << Hash[Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
-                             .zip(Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
+              @mounts << Hash[Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
+                              .zip(Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
                 .map { |v| binding.local_variable_get(v) })]
             end
-            @fact_list[:mountpoints] = mounts
+
+            exclude_auto_home_mounts!
+
+            @fact_list[:mountpoints] = @mounts
             @fact_list[fact_name]
           end
         end