facter 4.0.42 → 4.0.48

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

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

data/lib/facter/resolvers/freebsd/{freebsd_version_resolver.rb → freebsd_version.rb}

@@ -4,7 +4,7 @@ module Facter
   module Resolvers
     module Freebsd
       class FreebsdVersion < BaseResolver
-        @fact_list ||= {}
+        init_resolver
 
         class << self
           private
@@ -14,10 +14,13 @@ module Facter
           end
 
           def freebsd_version_system_call(fact_name)
-            output = Facter::Core::Execution.execute('/bin/freebsd-version -kru', logger: log)
-            return if output.empty?
+            output = Facter::Core::Execution.execute('/bin/freebsd-version -k', logger: log)
 
-            build_fact_list(output)
+            @fact_list[:installed_kernel] = output.strip unless output.empty?
+
+            output = Facter::Core::Execution.execute('/bin/freebsd-version -ru', logger: log)
+
+            build_fact_list(output) unless output.empty?
 
             @fact_list[fact_name]
           end
@@ -25,9 +28,8 @@ module Facter
           def build_fact_list(output)
             freebsd_version_results = output.split("\n")
 
-            @fact_list[:installed_kernel]   = freebsd_version_results[0].strip
-            @fact_list[:running_kernel]     = freebsd_version_results[1].strip
-            @fact_list[:installed_userland] = freebsd_version_results[2].strip
+            @fact_list[:running_kernel]     = freebsd_version_results[0].strip
+            @fact_list[:installed_userland] = freebsd_version_results[1].strip
           end
         end
       end

data/lib/facter/resolvers/freebsd/{geom_resolver.rb → geom.rb}

@@ -4,7 +4,10 @@ module Facter
   module Resolvers
     module Freebsd
       class Geom < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
+        DISKS_ATTRIBUTES = %i[read_model read_serial_number read_size].freeze
+        PARTITIONS_ATTRIBUTES = %i[read_partlabel read_partuuid read_size].freeze
 
         class << self
           private
@@ -17,37 +20,27 @@ module Facter
             require_relative 'ffi/ffi_helper'
             require 'rexml/document'
 
-            read_disks
-            read_partitions
+            topology = geom_topology
+            read_data('DISK', topology, DISKS_ATTRIBUTES)
+            read_data('PART', topology, PARTITIONS_ATTRIBUTES)
 
             @fact_list[fact_name]
           end
 
-          def read_disks
-            @fact_list[:disks] = {}
-
-            each_geom_class_provider('DISK') do |provider|
-              name = provider.get_text('./name').value
-
-              @fact_list[:disks][name] = %i[read_model read_serial_number read_size].map do |x|
-                send(x, provider)
-              end.inject(:merge)
-            end
-          end
-
-          def read_partitions
-            @fact_list[:partitions] = {}
+          def read_data(fact_name, geom_topology, data_to_read)
+            fact_list_key = fact_name == 'DISK' ? :disks : :partitions
+            @fact_list[fact_list_key] = {}
 
-            each_geom_class_provider('PART') do |provider|
+            each_geom_class_provider(fact_name, geom_topology) do |provider|
               name = provider.get_text('./name').value
 
-              @fact_list[:partitions][name] = %i[read_partlabel read_partuuid read_size].map do |x|
+              @fact_list[fact_list_key][name] = data_to_read.map do |x|
                 send(x, provider)
               end.inject(:merge)
             end
           end
 
-          def each_geom_class_provider(geom_class_name, &block)
+          def each_geom_class_provider(geom_class_name, geom_topology, &block)
             REXML::XPath.each(geom_topology, "/mesh/class[name/text() = '#{geom_class_name}']/geom/provider", &block)
           end
 
@@ -58,7 +51,7 @@ module Facter
             mediasize = Integer(mediasize.value)
 
             res[:size_bytes] = mediasize
-            res[:size] = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(mediasize)
+            res[:size] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(mediasize)
             res
           end
 
@@ -95,7 +88,7 @@ module Facter
           end
 
           def geom_topology
-            @geom_topology ||= REXML::Document.new(geom_confxml)
+            REXML::Document.new(geom_confxml)
           end
 
           def geom_confxml

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

@@ -6,8 +6,9 @@ module Facter
   module Resolvers
     module Freebsd
       class Processors < BaseResolver
+        init_resolver
         @log = Facter::Log.new(self)
-        @fact_list ||= {}
+
         class << self
           private
 
@@ -18,23 +19,27 @@ module Facter
           def collect_processors_info(fact_name)
             require 'facter/resolvers/freebsd/ffi/ffi_helper'
 
-            @fact_list[:logical_count] = logical_count
-            @fact_list[:models] = Array.new(logical_count, model) if logical_count && model
+            count = logical_count
+            model = processors_model
+            speed = processors_speed
+
+            @fact_list[:logical_count] = count
+            @fact_list[:models] = Array.new(count, model) if logical_count && model
             @fact_list[:speed] = speed * 1000 * 1000 if speed
 
             @fact_list[fact_name]
           end
 
-          def model
-            @model ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'hw.model')
+          def processors_model
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:string, 'hw.model')
           end
 
           def logical_count
-            @logical_count ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.ncpu')
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.ncpu')
           end
 
-          def speed
-            @speed ||= Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.clockrate')
+          def processors_speed
+            Facter::Freebsd::FfiHelper.sysctl_by_name(:uint32_t, 'hw.clockrate')
           end
         end
       end

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

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     module Freebsd
       class SwapMemory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
@@ -20,8 +21,9 @@ module Facter
               @fact_list[:total_bytes]     = kilobytes_to_bytes(data.map { |line| line[1].to_i }.inject(:+))
               @fact_list[:used_bytes]      = kilobytes_to_bytes(data.map { |line| line[2].to_i }.inject(:+))
               @fact_list[:available_bytes] = kilobytes_to_bytes(data.map { |line| line[3].to_i }.inject(:+))
-              @fact_list[:capacity] = FilesystemHelper.compute_capacity(@fact_list[:used_bytes],
-                                                                        @fact_list[:total_bytes])
+              @fact_list[:capacity] = Facter::Util::Resolvers::FilesystemHelper
+                                      .compute_capacity(@fact_list[:used_bytes],
+                                                        @fact_list[:total_bytes])
               @fact_list[:encrypted] = data.map { |line| line[0].end_with?('.eli') }.all?
             end
 

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

@@ -4,7 +4,8 @@ module Facter
   module Resolvers
     module Freebsd
       class SystemMemory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
@@ -17,7 +18,8 @@ module Facter
             read_available_memory_in_bytes
 
             @fact_list[:used_bytes] = @fact_list[:total_bytes] - @fact_list[:available_bytes]
-            @fact_list[:capacity] = FilesystemHelper.compute_capacity(@fact_list[:used_bytes], @fact_list[:total_bytes])
+            @fact_list[:capacity] = Facter::Util::Resolvers::FilesystemHelper
+                                    .compute_capacity(@fact_list[:used_bytes], @fact_list[:total_bytes])
 
             @fact_list[fact_name]
           end

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