facter 4.0.44 → 4.0.50

data/lib/facter/resolvers/open_vz.rb

@@ -5,19 +5,17 @@ module Facter
     class OpenVz < BaseResolver
       # build
 
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { check_proc_vz(fact_name) }
         end
 
         def check_proc_vz(fact_name)
-          if !Dir.exist?('/proc/vz') || !File.executable?('/proc/lve/list') || Dir.entries('/proc/vz').count.equal?(2)
-            return
-          end
+          return if !Dir.exist?('/proc/vz') || File.file?('/proc/lve/list') || Dir.entries('/proc/vz').count.equal?(2)
 
           @fact_list[:vm] = read_proc_status
           @fact_list[fact_name]

data/lib/facter/resolvers/{os_release_resolver.rb → os_release.rb}

@@ -14,17 +14,17 @@ module Facter
       # :support_url
       # :bug_report_url
 
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_os_release_file(fact_name) }
         end
 
         def read_os_release_file(fact_name)
-          output = Util::FileHelper.safe_readlines('/etc/os-release')
+          output = Facter::Util::FileHelper.safe_readlines('/etc/os-release')
           return @fact_list[:name] = nil if output.empty?
 
           pairs = []

data/lib/facter/resolvers/partitions.rb

@@ -3,14 +3,15 @@
 module Facter
   module Resolvers
     class Partitions < BaseResolver
-      @fact_list ||= {}
+      init_resolver
+
       BLOCK_PATH = '/sys/block'
       BLOCK_SIZE = 512
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_partitions(fact_name) }
         end
 
@@ -44,7 +45,7 @@ module Facter
         end
 
         def extract_from_dm(block_path, block_device, blkid_and_lsblk)
-          map_name = Util::FileHelper.safe_read("#{block_path}/dm/name").chomp
+          map_name = Facter::Util::FileHelper.safe_read("#{block_path}/dm/name").chomp
           if map_name.empty?
             populate_partitions("/dev/#{block_device}", block_path, blkid_and_lsblk)
           else
@@ -53,7 +54,7 @@ module Facter
         end
 
         def extract_from_loop(block_path, block_device, blkid_and_lsblk)
-          backing_file = Util::FileHelper.safe_read("#{block_path}/loop/backing_file").chomp
+          backing_file = Facter::Util::FileHelper.safe_read("#{block_path}/loop/backing_file").chomp
           if backing_file.empty?
             populate_partitions("/dev/#{block_device}", block_path, blkid_and_lsblk)
           else
@@ -62,10 +63,10 @@ module Facter
         end
 
         def populate_partitions(partition_name, block_path, blkid_and_lsblk, backing_file = nil)
-          size_bytes = Util::FileHelper.safe_read("#{block_path}/size", '0')
-                                       .chomp.to_i * BLOCK_SIZE
+          size_bytes = Facter::Util::FileHelper.safe_read("#{block_path}/size", '0')
+                                               .chomp.to_i * BLOCK_SIZE
           info_hash = { size_bytes: size_bytes,
-                        size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes),
+                        size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes),
                         backing_file: backing_file }
           info_hash.merge!(populate_from_syscalls(partition_name, blkid_and_lsblk))
           @fact_list[:partitions][partition_name] = info_hash.reject { |_key, value| value.nil? }

data/lib/facter/resolvers/{path_resolver.rb → path.rb}

@@ -3,12 +3,12 @@
 module Facter
   module Resolvers
     class Path < 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_path_from_env }
         end
 

data/lib/facter/resolvers/{processors_resolver.rb → processors.rb}

@@ -5,8 +5,11 @@ module Facter
     module Linux
       class Processors < BaseResolver
         @log = Facter::Log.new(self)
-        @fact_list ||= {}
+
+        init_resolver
+
         MHZ_TO_HZ = 1_000_000
+
         class << self
           # :count
           # :models
@@ -15,12 +18,12 @@ module Facter
 
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_cpuinfo(fact_name) }
           end
 
           def read_cpuinfo(fact_name)
-            cpuinfo_output = Util::FileHelper.safe_readlines('/proc/cpuinfo')
+            cpuinfo_output = Facter::Util::FileHelper.safe_readlines('/proc/cpuinfo')
             return if cpuinfo_output.empty?
 
             read_processors(cpuinfo_output) # + model names
@@ -62,7 +65,7 @@ module Facter
                .select { |dir| dir =~ /cpu[0-9]+$/ }
                .select { |dir| File.exist?("/sys/devices/system/cpu/#{dir}/topology/physical_package_id") }
                .map do |dir|
-              Util::FileHelper.safe_read("/sys/devices/system/cpu/#{dir}/topology/physical_package_id").strip
+              Facter::Util::FileHelper.safe_read("/sys/devices/system/cpu/#{dir}/topology/physical_package_id").strip
             end
                .uniq.count
           end

data/lib/facter/resolvers/{redhat_release_resolver.rb → redhat_release.rb}

@@ -7,17 +7,17 @@ module Facter
       # :version
       # :codename
 
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { read_redhat_release(fact_name) }
         end
 
         def read_redhat_release(fact_name)
-          output = Util::FileHelper.safe_read('/etc/redhat-release', nil)
+          output = Facter::Util::FileHelper.safe_read('/etc/redhat-release', nil)
           return @fact_list[fact_name] = nil if output.nil?
 
           build_fact_list(output)

data/lib/facter/resolvers/release_from_first_line.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class ReleaseFromFirstLine < BaseResolver
+      # :release
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, options)
+          @fact_list.fetch(fact_name) { read_release_file(fact_name, options) }
+        end
+
+        def read_release_file(fact_name, options)
+          release_file = options[:release_file]
+          return unless release_file
+
+          output = Facter::Util::FileHelper.safe_read(release_file, nil)
+          return @fact_list[fact_name] = nil if output.nil?
+
+          @fact_list[:release] = retrieve_version(output)
+
+          @fact_list[fact_name]
+        end
+
+        def retrieve_version(output)
+          if output[/(Rawhide)$/]
+            'Rawhide'
+          elsif output['release']
+            output.strip =~ /release (\d[\d.]*)/ ? Regexp.last_match(1) : nil
+          else
+            output.strip =~ /Amazon Linux (\d+)/ ? Regexp.last_match(1) : nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/{ruby_resolver.rb → ruby.rb}

@@ -3,12 +3,12 @@
 module Facter
   module Resolvers
     class Ruby < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { retrieve_ruby_information(fact_name) }
         end
 

data/lib/facter/resolvers/{selinux_resolver.rb → selinux.rb}

@@ -3,12 +3,12 @@
 module Facter
   module Resolvers
     class SELinux < BaseResolver
-      @fact_list ||= {}
+      init_resolver
 
       class << self
         private
 
-        def post_resolve(fact_name)
+        def post_resolve(fact_name, _options)
           @fact_list.fetch(fact_name) { retrieve_facts(fact_name) }
         end
 
@@ -40,9 +40,9 @@ module Facter
           enforce_file = "#{mountpoint}/enforce"
           policy_file = "#{mountpoint}/policyvers"
 
-          @fact_list[:policy_version] = Util::FileHelper.safe_read(policy_file, nil)
+          @fact_list[:policy_version] = Facter::Util::FileHelper.safe_read(policy_file, nil)
 
-          enforce = Util::FileHelper.safe_read(enforce_file)
+          enforce = Facter::Util::FileHelper.safe_read(enforce_file)
           if enforce.eql?('1')
             @fact_list[:enforced] = true
             @fact_list[:current_mode] = 'enforcing'
@@ -53,7 +53,7 @@ module Facter
         end
 
         def read_selinux_config
-          file_lines = Util::FileHelper.safe_readlines('/etc/selinux/config')
+          file_lines = Facter::Util::FileHelper.safe_readlines('/etc/selinux/config')
 
           file_lines.map do |line|
             @fact_list[:config_mode] = line.split('=').last.strip if line =~ /^SELINUX=/

data/lib/facter/resolvers/solaris/disks.rb

@@ -4,12 +4,12 @@ module Facter
   module Resolvers
     module Solaris
       class Disks < 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_disks_info(fact_name) }
           end
 
@@ -36,7 +36,7 @@ module Facter
               disk_size = sizes[index].to_i
               disks[name] = {
                 product: products[index],
-                size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(disk_size),
+                size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(disk_size),
                 size_bytes: disk_size,
                 vendor: vendors[index]
               }

data/lib/facter/resolvers/solaris/dmi.rb

@@ -4,12 +4,12 @@ module Facter
   module Resolvers
     module Solaris
       class Dmi < 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_facts(fact_name) }
           end
 

data/lib/facter/resolvers/solaris/dmi_sparc.rb

@@ -4,12 +4,12 @@ module Facter
   module Resolvers
     module Solaris
       class DmiSparc < 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_facts(fact_name) }
           end
 

data/lib/facter/resolvers/solaris/filesystems.rb

@@ -4,12 +4,12 @@ module Facter
   module Resolvers
     module Solaris
       class Filesystem < 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_sysdef_file(fact_name) }
           end
 

data/lib/facter/resolvers/solaris/ipaddress.rb

@@ -4,11 +4,12 @@ module Facter
   module Resolvers
     module Solaris
       class Ipaddress < 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_ipaddress(fact_name) }
           end
 

data/lib/facter/resolvers/solaris/ldom.rb

@@ -14,7 +14,7 @@ module Facter
         # :role_service
         # :role_impl
 
-        @fact_list ||= {}
+        init_resolver
 
         VIRTINFO_MAPPING = {
           chassis_serial: %w[DOMAINCHASSIS serialno],
@@ -31,13 +31,11 @@ module Facter
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { call_virtinfo(fact_name) }
           end
 
           def call_virtinfo(fact_name)
-            # return unless File.executable?('/usr/sbin/virtinfo')
-
             virtinfo_output = Facter::Core::Execution.execute('/usr/sbin/virtinfo  -a  -p', logger: log)
             return if virtinfo_output.empty?
 

data/lib/facter/resolvers/solaris/memory.rb

@@ -4,14 +4,15 @@ module Facter
   module Resolvers
     module Solaris
       class Memory < BaseResolver
+        init_resolver
         BLOCKSIZE = 512
         # :system
         # :swap
-        @fact_list ||= {}
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { calculate_memory(fact_name) }
           end
 
@@ -31,7 +32,7 @@ module Facter
             sys[:total_bytes] = total
             sys[:available_bytes] = free
             sys[:used_bytes] = total - free
-            sys[:capacity] = FilesystemHelper.compute_capacity(total - free, total)
+            sys[:capacity] = Facter::Util::Resolvers::FilesystemHelper.compute_capacity(total - free, total)
 
             sys
           end
@@ -44,7 +45,7 @@ module Facter
             swap_hash[:total_bytes] = total
             swap_hash[:available_bytes] = free
             swap_hash[:used_bytes] = total - free
-            swap_hash[:capacity] = FilesystemHelper.compute_capacity(total - free, total)
+            swap_hash[:capacity] = Facter::Util::Resolvers::FilesystemHelper.compute_capacity(total - free, total)
 
             swap_hash if total != 0
           end

data/lib/facter/resolvers/solaris/mountpoints.rb

@@ -4,18 +4,18 @@ module Facter
   module Resolvers
     module Solaris
       class Mountpoints < BaseResolver
-        include Facter::FilesystemHelper
-        @fact_list ||= {}
-        @log = Facter::Log.new(self)
+        include Facter::Util::Resolvers::FilesystemHelper
+        init_resolver
+
         class << self
           private
 
-          def post_resolve(fact_name)
+          def post_resolve(fact_name, _options)
             @fact_list.fetch(fact_name) { read_mounts(fact_name) }
           end
 
           def root_device
-            cmdline = Util::FileHelper.safe_read('/proc/cmdline')
+            cmdline = Facter::Util::FileHelper.safe_read('/proc/cmdline')
             match = cmdline.match(/root=([^\s]+)/)
             match&.captures&.first
           end
@@ -27,27 +27,28 @@ module Facter
             device
           end
 
-          def read_mounts(fact_name) # rubocop:disable Metrics/AbcSize
+          def read_mounts(fact_name) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
             mounts = []
-            FilesystemHelper.read_mountpoints.each do |fs|
+            Facter::Util::Resolvers::FilesystemHelper.read_mountpoints.each do |fs|
               device = compute_device(fs.name)
               filesystem = fs.mount_type
               path = fs.mount_point
               options = fs.options.split(',').map(&:strip)
 
-              stats = FilesystemHelper.read_mountpoint_stats(path)
+              stats = Facter::Util::Resolvers::FilesystemHelper.read_mountpoint_stats(path)
               size_bytes = stats.bytes_total.abs
               available_bytes = stats.bytes_available.abs
 
               used_bytes = stats.bytes_used.abs
               total_bytes = used_bytes + available_bytes
-              capacity = FilesystemHelper.compute_capacity(used_bytes, total_bytes)
+              capacity = Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used_bytes, total_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)
+              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)
 
-              mounts << Hash[FilesystemHelper::MOUNT_KEYS.zip(FilesystemHelper::MOUNT_KEYS
+              mounts << Hash[Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
+                             .zip(Facter::Util::Resolvers::FilesystemHelper::MOUNT_KEYS
                 .map { |v| binding.local_variable_get(v) })]
             end
             @fact_list[:mountpoints] = mounts