facter 4.0.46 → 4.0.51

data/lib/facter/resolvers/debian_version.rb

@@ -12,12 +12,12 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_debian_version(fact_name) }
         end
 
         def read_debian_version(fact_name)
-          file_content = Util::FileHelper.safe_read('/etc/debian_version')
+          file_content = Facter::Util::FileHelper.safe_read('/etc/debian_version')
           @fact_list[:version] = file_content.strip unless file_content.empty?
 
           @fact_list[fact_name]

data/lib/facter/resolvers/{disk_resolver.rb → disk.rb}

@@ -14,7 +14,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_facts(fact_name) }
           end
 
@@ -25,7 +25,7 @@ module Facter
               @fact_list[:disks].each do |disk, value|
                 file_path = File.join(DIR, disk, file)
 
-                result = Util::FileHelper.safe_read(file_path).strip
+                result = Facter::Util::FileHelper.safe_read(file_path).strip
                 next if result.empty?
 
                 value[key] = case key
@@ -55,7 +55,7 @@ module Facter
           def construct_size(facts, value)
             value = value.to_i * 512
             facts[:size_bytes] = value
-            facts[:size] = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(value)
+            facts[:size] = Facter::Util::Facts::UnitConverter.bytes_to_human_readable(value)
           end
         end
       end

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

@@ -25,7 +25,7 @@ module Facter
 
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_facts(fact_name) }
           end
 
@@ -35,7 +35,7 @@ module Facter
                        product_serial product_uuid]
             return unless File.directory?('/sys/class/dmi')
 
-            file_content = Util::FileHelper.safe_read("/sys/class/dmi/id/#{fact_name}", nil)
+            file_content = Facter::Util::FileHelper.safe_read("/sys/class/dmi/id/#{fact_name}", nil)
             if files.include?(fact_name.to_s) && file_content
               file_content = file_content.strip
               @fact_list[fact_name] = file_content unless file_content.empty?

data/lib/facter/resolvers/dmi_decode.rb

@@ -27,7 +27,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { run_dmidecode(fact_name) }
         end
 

data/lib/facter/resolvers/ec2.rb

@@ -12,7 +12,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           log.debug('Querying Ec2 metadata')
           @fact_list.fetch(fact_name) { read_facts(fact_name) }
         end
@@ -50,7 +50,9 @@ module Facter
         end
 
         def get_data_from(url)
-          Utils::Http.get_request(url, {}, { session: determine_session_timeout })
+          headers = {}
+          headers['X-aws-ec2-metadata-token'] = Facter::Util::Resolvers::AwsToken.get if ENV['AWS_IMDSv2']
+          Facter::Util::Resolvers::Http.get_request(url, headers, { session: determine_session_timeout })
         end
 
         def determine_session_timeout

data/lib/facter/resolvers/{eos_release_resolver.rb → eos_release.rb}

@@ -12,12 +12,12 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_eos_release(fact_name) }
         end
 
         def read_eos_release(fact_name)
-          output = Util::FileHelper.safe_read('/etc/Eos-release', nil)
+          output = Facter::Util::FileHelper.safe_read('/etc/Eos-release', nil)
           return @fact_list[fact_name] = nil if output.nil?
 
           output_strings = output.split(' ')

data/lib/facter/resolvers/{facterversion_resolver.rb → facterversion.rb}

@@ -8,7 +8,7 @@ module Facter
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_version_file }
         end
 

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

@@ -13,12 +13,12 @@ module Facter
         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}

@@ -13,12 +13,12 @@ module Facter
         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}

@@ -11,7 +11,7 @@ module Facter
 
           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}

@@ -9,7 +9,7 @@ module Facter
         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
 

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

@@ -12,7 +12,7 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_facts(fact_name) }
           end
 
@@ -51,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

@@ -12,7 +12,7 @@ module Facter
         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}

@@ -9,7 +9,7 @@ module Facter
         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
 
@@ -21,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}

@@ -9,7 +9,7 @@ module Facter
         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
 
@@ -18,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

@@ -11,7 +11,7 @@ module Facter
       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
@@ -22,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}

@@ -10,7 +10,7 @@ module Facter
       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

@@ -9,14 +9,14 @@ module Facter
         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

@@ -9,12 +9,12 @@ module Facter
         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

@@ -8,15 +8,16 @@ module Facter
       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