facter 4.0.44 → 4.0.50

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

@@ -5,17 +5,20 @@ module Facter
     module Linux
       class Filesystems < BaseResolver
         # :systems
-        @fact_list ||= {}
+
+        init_resolver
+
         @log = Facter::Log.new(self)
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_filesystems(fact_name) }
           end
 
           def read_filesystems(fact_name)
-            output = Util::FileHelper.safe_readlines('/proc/filesystems', nil)
+            output = Facter::Util::FileHelper.safe_readlines('/proc/filesystems', nil)
             return unless output
 
             filesystems = []

data/lib/facter/resolvers/{fips_enabled_resolver.rb → fips_enabled.rb}

@@ -5,17 +5,20 @@ module Facter
     module Linux
       class FipsEnabled < BaseResolver
         #:fips_enabled
-        @fact_list ||= {}
+
+        init_resolver
+
         @log = Facter::Log.new(self)
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_fips_file(fact_name) }
           end
 
           def read_fips_file(fact_name)
-            file_output = Util::FileHelper.safe_read('/proc/sys/crypto/fips_enabled')
+            file_output = Facter::Util::FileHelper.safe_read('/proc/sys/crypto/fips_enabled')
             @fact_list[:fips_enabled] = file_output.strip == '1'
             @fact_list[fact_name]
           end

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

@@ -4,14 +4,14 @@ module Facter
   module Resolvers
     module Freebsd
       class DmiBios < BaseResolver
-        @fact_list ||= {}
+        init_resolver
 
         class << self
           #:model
 
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_facts(fact_name) }
           end
 

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

@@ -4,20 +4,23 @@ module Facter
   module Resolvers
     module Freebsd
       class FreebsdVersion < BaseResolver
-        @fact_list ||= {}
+        init_resolver
 
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { freebsd_version_system_call(fact_name) }
           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,14 +4,15 @@ 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
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_facts(fact_name) }
           end
 
@@ -50,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
 

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

@@ -6,12 +6,13 @@ module Facter
   module Resolvers
     module Freebsd
       class Processors < BaseResolver
+        init_resolver
         @log = Facter::Log.new(self)
-        @fact_list ||= {}
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { collect_processors_info(fact_name) }
           end
 

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

@@ -4,11 +4,12 @@ module Facter
   module Resolvers
     module Freebsd
       class SwapMemory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_swap_memory(fact_name) }
           end
 
@@ -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,11 +4,12 @@ module Facter
   module Resolvers
     module Freebsd
       class SystemMemory < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { calculate_system_memory(fact_name) }
           end
 
@@ -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, _options)
+            @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,14 +3,15 @@
 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
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           log.debug('reading Gce metadata')
           @fact_list.fetch(fact_name) { read_facts(fact_name) }
         end
@@ -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, _options)
+          @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,12 +4,13 @@ module Facter
   module Resolvers
     class PosxIdentity < BaseResolver
       @log = Facter::Log.new(self)
-      @fact_list ||= {}
+
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { retrieve_identity(fact_name) }
         end
 

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

@@ -4,18 +4,19 @@ module Facter
   module Resolvers
     module Linux
       class DockerUptime < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { detect_uptime(fact_name) }
           end
 
           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,16 +4,17 @@ module Facter
   module Resolvers
     module Linux
       class LoadAverages < BaseResolver
-        @fact_list ||= {}
+        init_resolver
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_load_averages_file(fact_name) }
           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,19 +3,21 @@
 module Facter
   module Resolvers
     class LoadAverages < BaseResolver
-      @fact_list ||= {}
+      init_resolver
+
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_load_averages(fact_name) }
         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