facter 4.0.43 → 4.0.49

data/lib/facter/resolvers/hostname.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Hostname < BaseResolver
+      # :fqdn
+      # :domain
+      # :hostname
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
+        end
+
+        def retrieve_info(fact_name)
+          require 'socket'
+          output = Socket.gethostname
+          hostname, domain = retrieve_from_fqdn(output)
+
+          fqdn = retrieve_with_addrinfo(hostname) if hostname_and_no_domain?(hostname, domain)
+
+          _, domain = retrieve_from_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 retrieve_from_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_with_addrinfo(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}")
+            return
+          end
+          return if name.nil? || name.empty? || host == name[2] || name[2] == name[3]
+
+          name[2]
+        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

data/lib/facter/resolvers/{identity_resolver.rb → identity.rb}

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     class PosxIdentity < BaseResolver
       @log = Facter::Log.new(self)
-      @fact_list ||= {}
+
+      init_resolver
 
       class << self
         private

data/lib/facter/resolvers/linux/docker_uptime.rb

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     module Linux
       class DockerUptime < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
@@ -15,7 +16,7 @@ module Facter
           def detect_uptime(fact_name)
             days, hours, minutes, seconds = extract_uptime_from_docker
             total_seconds = convert_to_seconds(days, hours, minutes, seconds)
-            @fact_list = Utils::UptimeHelper.create_uptime_hash(total_seconds)
+            @fact_list =  Facter::Util::Resolvers::UptimeHelper.create_uptime_hash(total_seconds)
 
             @fact_list[fact_name]
           end

data/lib/facter/resolvers/linux/load_averages.rb

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     module Linux
       class LoadAverages < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
@@ -13,7 +14,7 @@ module Facter
           end
 
           def read_load_averages_file(fact_name)
-            output = Util::FileHelper.safe_read('/proc/loadavg')
+            output = Facter::Util::FileHelper.safe_read('/proc/loadavg')
             @fact_list[:load_averages] = {}.tap { |h| h['1m'], h['5m'], h['15m'], = output.split.map(&:to_f) }
 
             @fact_list[fact_name]

data/lib/facter/resolvers/load_averages.rb

@@ -3,7 +3,8 @@
 module Facter
   module Resolvers
     class LoadAverages < BaseResolver
-      @fact_list ||= {}
+      init_resolver
+
       class << self
         private
 
@@ -12,10 +13,11 @@ module Facter
         end
 
         def read_load_averages(fact_name)
-          require_relative 'utils/ffi/load_averages'
+          require 'facter/util/resolvers/ffi/load_averages'
 
           log.debug('loading cpu load averages')
-          @fact_list[:load_averages] = %w[1m 5m 15m].zip(Utils::Ffi::LoadAverages.read_load_averages).to_h
+          @fact_list[:load_averages] = %w[1m 5m 15m].zip(Facter::Util::Resolvers::Ffi::LoadAverages
+            .read_load_averages).to_h
 
           @fact_list[fact_name]
         end

data/lib/facter/resolvers/{lpar_resolver.rb → lpar.rb}

@@ -3,7 +3,7 @@
 module Facter
   module Resolvers
     class Lpar < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private

data/lib/facter/resolvers/{lsb_release_resolver.rb → lsb_release.rb}

@@ -9,7 +9,7 @@ module Facter
       # :release
       # :codename
 
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private

data/lib/facter/resolvers/lspci.rb

@@ -3,7 +3,7 @@
 module Facter
   module Resolvers
     class Lspci < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       REGEX_VALUES = { 'VirtualBox' => 'virtualbox', 'XenSource' => 'xenhvm',
                        'Microsoft Corporation Hyper-V' => 'hyperv', 'Class 8007: Google, Inc' => 'gce',

data/lib/facter/resolvers/macosx/{dmi_resolver.rb → dmi.rb}

@@ -4,7 +4,7 @@ module Facter
   module Resolvers
     module Macosx
       class DmiBios < BaseResolver
-        @fact_list ||= {}
+        init_resolver
 
         class << self
           #:model

data/lib/facter/resolvers/macosx/{filesystems_resolver.rb → filesystems.rb}

@@ -5,7 +5,7 @@ module Facter
     module Macosx
       class Filesystems < BaseResolver
         # :macosx_filesystems
-        @fact_list ||= {}
+        init_resolver
 
         class << self
           private

data/lib/facter/resolvers/macosx/{load_averages_resolver.rb → load_averages.rb}

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     module Macosx
       class LoadAverages < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 

data/lib/facter/resolvers/macosx/{mountpoints_resolver.rb → mountpoints.rb}

@@ -4,8 +4,9 @@ module Facter
   module Resolvers
     module Macosx
       class Mountpoints < BaseResolver
-        include Facter::FilesystemHelper
-        @fact_list ||= {}
+        include Facter::Util::Resolvers::FilesystemHelper
+        init_resolver
+
         class << self
           private
 
@@ -16,7 +17,7 @@ module Facter
           def read_mounts
             mounts = {}
 
-            FilesystemHelper.read_mountpoints.each do |fs|
+            Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |fs|
               device = fs.name
               filesystem = fs.mount_type
               path = fs.mount_point
@@ -34,7 +35,7 @@ module Facter
 
           def read_stats(path)
             begin
-              stats = FilesystemHelper.read_mountpoint_stats(path)
+              stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(path)
               size_bytes = stats.bytes_total
               available_bytes = stats.bytes_available
               used_bytes = size_bytes - available_bytes
@@ -46,10 +47,10 @@ module Facter
               size_bytes: size_bytes,
               used_bytes: used_bytes,
               available_bytes: available_bytes,
-              capacity: FilesystemHelper.compute_capacity(used_bytes, size_bytes),
-              size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes),
-              available: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(available_bytes),
-              used: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(used_bytes)
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used_bytes, size_bytes),
+              size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes),
+              available: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(available_bytes),
+              used: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(used_bytes)
             }
           end
         end

data/lib/facter/resolvers/macosx/{processor_resolver.rb → processor.rb}

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     module Macosx
       class Processors < BaseResolver
-        @fact_list = {}
+        init_resolver
+
         ITEMS = { logical_count: 'hw.logicalcpu_max',
                   physical_count: 'hw.physicalcpu_max',
                   brand: 'machdep.cpu.brand_string',

data/lib/facter/resolvers/macosx/{swap_memory_resolver.rb → swap_memory.rb}

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     module Macosx
       class SwapMemory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 

data/lib/facter/resolvers/macosx/{system_memory_resolver.rb → system_memory.rb}

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     module Macosx
       class SystemMemory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 

data/lib/facter/resolvers/macosx/{system_profiler_resolver.rb → system_profiler.rb}

@@ -15,7 +15,7 @@ module Facter
         SP_ETHERNET_DATA_TYPE = %i[type bus vendor_id device_id subsystem_vendor_id
                                    subsystem_id revision_id bsd_name kext_name location version].freeze
 
-        @fact_list = {}
+        init_resolver
 
         class << self
           private
@@ -25,15 +25,13 @@ module Facter
           end
 
           def retrieve_system_profiler(fact_name)
-            @fact_list ||= {}
-
             case fact_name
             when *SP_HARDWARE_DATA_TYPE
-              @fact_list.merge!(SystemProfileExecutor.execute('SPHardwareDataType'))
+              @fact_list.merge!(Facter::Util::Macosx::SystemProfileExecutor.execute('SPHardwareDataType'))
             when *SP_SOFTWARE_DATA_TYPE
-              @fact_list.merge!(SystemProfileExecutor.execute('SPSoftwareDataType'))
+              @fact_list.merge!(Facter::Util::Macosx::SystemProfileExecutor.execute('SPSoftwareDataType'))
             when *SP_ETHERNET_DATA_TYPE
-              @fact_list.merge!(SystemProfileExecutor.execute('SPEthernetDataType'))
+              @fact_list.merge!(Facter::Util::Macosx::SystemProfileExecutor.execute('SPEthernetDataType'))
             end
 
             @fact_list[fact_name]

data/lib/facter/resolvers/{memory_resolver.rb → memory.rb}

@@ -4,8 +4,10 @@ module Facter
   module Resolvers
     module Linux
       class Memory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         @log = Facter::Log.new(self)
+
         class << self
           private
 
@@ -14,7 +16,7 @@ module Facter
           end
 
           def read_meminfo_file(fact_name)
-            meminfo_output = Util::FileHelper.safe_read('/proc/meminfo', nil)
+            meminfo_output = Facter::Util::FileHelper.safe_read('/proc/meminfo', nil)
             return unless meminfo_output
 
             read_system(meminfo_output)

data/lib/facter/resolvers/mountpoints.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Mountpoints < BaseResolver
+      include Facter::Util::Resolvers::FilesystemHelper
+
+      init_resolver
+
+      @log = Facter::Log.new(self)
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @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]+)/)
+          root = match&.captures&.first
+
+          if !root.nil? && root.include?('=')
+            # We are dealing with the PARTUUID of the partition. Need to extract partition path.
+            root_partition_path = convert_partuuid_to_path(root)
+            root = root_partition_path unless root_partition_path.nil?
+          end
+          root
+        end
+
+        def convert_partuuid_to_path(root)
+          blkid_content = Facter::Core::Execution.execute('blkid', logger: log)
+          partuuid = root.split('=').last
+          match = blkid_content.match(/(.+)#{partuuid}/)
+          match&.captures&.first&.split(':')&.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
+        end
+
+        def read_mounts(fact_name)
+          mounts = []
+          Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |file_system|
+            mount = {}
+            get_mount_data(file_system, mount)
+
+            next if mount[:path] =~ %r{^/(proc|sys)} && mount[:filesystem] != 'tmpfs' || mount[:filesystem] == 'autofs'
+
+            get_mount_sizes(mount)
+            mounts << mount
+          end
+
+          @fact_list[:mountpoints] = mounts
+          @fact_list[fact_name]
+        end
+
+        def get_mount_data(file_system, mount)
+          mount[:device] = compute_device(file_system.name)
+          mount[:filesystem] = file_system.mount_type
+          mount[:path] = file_system.mount_point
+          mount[:options] = file_system.options.split(',').map(&:strip)
+        end
+
+        def get_mount_sizes(mount)
+          stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(mount[:path])
+
+          get_bytes_data(mount, stats)
+
+          total_bytes = mount[:used_bytes] + mount[:available_bytes]
+          mount[:capacity] = Facter::Util::Resolvers::FilesystemHelper.compute_capacity(mount[:used_bytes], total_bytes)
+
+          mount[:size] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mount[:size_bytes])
+          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
+end

data/lib/facter/resolvers/{networking_resolver.rb → networking.rb}

@@ -3,7 +3,7 @@
 module Facter
   module Resolvers
     class Networking < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
@@ -13,16 +13,19 @@ module Facter
         end
 
         def read_facts(fact_name)
-          primary_interface
           interfaces_data
-          ::Resolvers::Utils::Networking.expand_main_bindings(@fact_list)
+          primary_interface
+          Facter::Util::Resolvers::Networking.expand_main_bindings(@fact_list)
           @fact_list[fact_name]
         end
 
         def primary_interface
-          result = Facter::Core::Execution.execute('route -n get default', logger: log)
+          primary_helper = Facter::Util::Resolvers::Networking::PrimaryInterface
+          primary_interface ||= primary_helper.read_from_route
+
+          primary_interface ||= primary_helper.find_in_interfaces(@fact_list[:interfaces])
 
-          @fact_list[:primary_interface] = result.match(/interface: (.+)/)&.captures&.first
+          @fact_list[:primary_interface] = primary_interface
         end
 
         def interfaces_data
@@ -95,7 +98,7 @@ module Facter
         def create_bindings(ips, masks)
           bindings = []
           ips.zip(masks).each do |ip, mask|
-            bindings << ::Resolvers::Utils::Networking.build_binding(ip, mask)
+            bindings << Facter::Util::Resolvers::Networking.build_binding(ip, mask)
           end
           bindings
         end