facter 4.0.41 → 4.0.47

data/lib/facter/resolvers/freebsd/virtual_resolver.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Freebsd
+      class Virtual < BaseResolver
+        init_resolver
+
+        class << self
+          #:model
+
+          VM_GUEST_SYSCTL_NAMES = {
+            'hv' => 'hyperv',
+            'microsoft' => 'hyperv',
+            'oracle' => 'virtualbox',
+            'xen' => 'xenu',
+            'none' => nil
+          }.freeze
+
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            require_relative 'ffi/ffi_helper'
+
+            if Facter::Freebsd::FfiHelper.sysctl_by_name(:long, 'security.jail.jailed').zero?
+              vm = Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'kern.vm_guest')
+
+              vm = VM_GUEST_SYSCTL_NAMES[vm] if VM_GUEST_SYSCTL_NAMES.key?(vm)
+
+              @fact_list[:vm] = vm
+            else
+              @fact_list[:vm] = 'jail'
+            end
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/gce.rb

@@ -3,7 +3,8 @@
 module Facter
   module Resolvers
     class Gce < BaseResolver
-      @fact_list ||= {}
+      init_resolver
+
       METADATA_URL = 'http://metadata.google.internal/computeMetadata/v1/?recursive=true&alt=json'
       HEADERS = { "Metadata-Flavor": 'Google', "Accept": 'application/json' }.freeze
 
@@ -21,7 +22,7 @@ module Facter
         end
 
         def query_for_metadata
-          gce_data = extract_to_hash(Utils::Http.get_request(METADATA_URL, HEADERS))
+          gce_data = extract_to_hash(Facter::Util::Resolvers::Http.get_request(METADATA_URL, HEADERS))
           parse_instance(gce_data)
 
           gce_data.empty? ? nil : gce_data

data/lib/facter/resolvers/hostname_resolver.rb

@@ -3,40 +3,88 @@
 module Facter
   module Resolvers
     class Hostname < BaseResolver
-      @fact_list ||= {}
+      # :fqdn
+      # :domain
+      # :hostname
+
+      init_resolver
+
       class << self
         private
 
         def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { retrieve_hostname(fact_name) }
+          @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
         end
 
-        def retrieve_hostname(fact_name)
-          output = Facter::Core::Execution.execute('hostname', logger: log)
+        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)
 
-          # get domain
-          domain = read_domain(output)
+          _, domain = retrieve_from_fqdn(fqdn) if exists_and_valid_fqdn?(fqdn, hostname)
 
-          # get hostname
-          hostname = output =~ /(.*?)\./ ? Regexp.last_match(1) : output
-          @fact_list[:hostname] ||= hostname&.strip
-          @fact_list[:domain] ||= domain&.strip
-          @fact_list[:fqdn] ||= "#{@fact_list[:hostname]}.#{@fact_list[:domain]}"
+          domain = read_domain unless exists_and_not_empty?(domain)
+
+          construct_fact_list(hostname, domain, fqdn)
           @fact_list[fact_name]
         end
 
-        def read_domain(output)
-          if output =~ /.*?\.(.+$)/
-            domain = Regexp.last_match(1)
+        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
-            file_content = Util::FileHelper.safe_read('/etc/resolv.conf')
-            if file_content =~ /^search\s+(\S+)/
-              domain = Regexp.last_match(1)
-            elsif file_content =~ /^domain\s+(\S+)/
-              domain = Regexp.last_match(1)
-            end
+            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
-          domain
+        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

data/lib/facter/resolvers/identity_resolver.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

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

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

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

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

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

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

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

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

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

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

@@ -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)
@@ -25,11 +27,21 @@ module Facter
 
           def read_system(output)
             @fact_list[:total] = kilobytes_to_bytes(output.match(/MemTotal:\s+(\d+)\s/)[1])
-            @fact_list[:memfree] = kilobytes_to_bytes(output.match(/MemFree:\s+(\d+)\s/)[1])
-            @fact_list[:used_bytes] = compute_used(@fact_list[:total], reclaimable_memory(output))
+            @fact_list[:memfree] = memfree(output)
+            @fact_list[:used_bytes] = compute_used(@fact_list[:total], @fact_list[:memfree])
             @fact_list[:capacity] = compute_capacity(@fact_list[:used_bytes], @fact_list[:total])
           end
 
+          def memfree(output)
+            available = output.match(/MemAvailable:\s+(\d+)\s/)
+            return kilobytes_to_bytes(available[1]) if available
+
+            buffers = kilobytes_to_bytes(output.match(/Buffers:\s+(\d+)\s/)[1])
+            cached = kilobytes_to_bytes(output.match(/Cached:\s+(\d+)\s/)[1])
+            memfree = kilobytes_to_bytes(output.match(/MemFree:\s+(\d+)\s/)[1])
+            memfree + buffers + cached
+          end
+
           def read_swap(output)
             total = output.match(/SwapTotal:\s+(\d+)\s/)[1]
             return if total.to_i.zero?
@@ -44,18 +56,6 @@ module Facter
             quantity.to_i * 1024
           end
 
-          def reclaimable_memory(output)
-            buffers = kilobytes_to_bytes(output.match(/Buffers:\s+(\d+)\s/)[1])
-            cached = kilobytes_to_bytes(output.match(/Cached:\s+(\d+)\s/)[1])
-            s_reclaimable = output.match(/SReclaimable:\s+(\d+)\s/)
-            s_reclaimable = if s_reclaimable
-                              kilobytes_to_bytes(s_reclaimable[1])
-                            else
-                              0
-                            end
-            @fact_list[:memfree] + buffers + cached + s_reclaimable
-          end
-
           def compute_capacity(used, total)
             format('%<computed_capacity>.2f', computed_capacity: (used / total.to_f * 100)) + '%'
           end