facter 4.0.15 → 4.0.16

data/lib/resolvers/aix/utils/odm_query.rb

@@ -27,9 +27,9 @@ module Facter
     def execute
       result = nil
       REPOS.each do |repo|
-        break if result
+        break if result && !result.empty?
 
-        result, _s = Open3.capture2("#{query} #{repo}")
+        result, _stderr, _s = Open3.capture3("#{query} #{repo}")
       end
       result
     end

data/lib/resolvers/debian_version.rb

@@ -18,11 +18,8 @@ module Facter
         end
 
         def read_debian_version(fact_name)
-          return unless File.readable?('/etc/debian_version')
-
-          verion = File.read('/etc/debian_version')
-
-          @fact_list[:version] = verion.strip
+          file_content = Util::FileHelper.safe_read('/etc/debian_version')
+          @fact_list[:version] = file_content.strip unless file_content.empty?
 
           @fact_list[fact_name]
         end

data/lib/resolvers/disk_resolver.rb

@@ -23,9 +23,8 @@ module Facter
               @fact_list[:disks].each do |disk, value|
                 file_path = File.join(DIR, disk, file)
 
-                next unless File.readable?(file_path)
-
-                result = File.read(file_path).strip
+                result = Util::FileHelper.safe_read(file_path).strip
+                next if result.empty?
 
                 # Linux always considers sectors to be 512 bytes long independently of the devices real block size.
                 value[key] = file =~ /size/ ? construct_size(value, result) : result

data/lib/resolvers/dmi_resolver.rb

@@ -28,15 +28,15 @@ module Facter
             @fact_list.fetch(fact_name) { read_facts(fact_name) }
           end
 
-          # File.read("/sys/class/dmi/id/#{file}")
           def read_facts(fact_name)
             files = %w[bios_date bios_vendor bios_version board_vendor board_name board_serial
                        chassis_asset_tag chassis_type sys_vendor product_name product_serial
                        product_uuid]
             return unless File.directory?('/sys/class/dmi')
 
-            if files.include?(fact_name.to_s) && File.readable?("/sys/class/dmi/id/#{fact_name}")
-              @fact_list[fact_name] = File.read("/sys/class/dmi/id/#{fact_name}").strip
+            file_content = Util::FileHelper.safe_read("/sys/class/dmi/id/#{fact_name}", nil)
+            if files.include?(fact_name.to_s) && file_content
+              @fact_list[fact_name] = file_content.strip
               chassis_to_name(@fact_list[fact_name]) if fact_name == :chassis_type
 
             end

data/lib/resolvers/filesystems_resolver.rb

@@ -16,11 +16,11 @@ module Facter
           end
 
           def read_filesystems(fact_name)
-            return unless File.readable?('/proc/filesystems')
+            output = Util::FileHelper.safe_readlines('/proc/filesystems', nil)
+            return unless output
 
-            output = File.read('/proc/filesystems')
             filesystems = []
-            output.each_line do |line|
+            output.each do |line|
               tokens = line.split(' ')
               filesystems << tokens if tokens.size == 1
             end

data/lib/resolvers/fips_enabled_resolver.rb

@@ -16,10 +16,7 @@ module Facter
           end
 
           def read_fips_file(fact_name)
-            return @fact_list[fact_name] = false unless File.directory?('/proc/sys/crypto') ||
-                                                        File.readable?('/proc/sys/crypto/fips_enabled')
-
-            file_output = File.read('/proc/sys/crypto/fips_enabled')
+            file_output = Util::FileHelper.safe_read('/proc/sys/crypto/fips_enabled')
             @fact_list[:fips_enabled] = file_output.strip == '1'
             @fact_list[fact_name]
           end

data/lib/resolvers/hostname_resolver.rb

@@ -30,11 +30,11 @@ module Facter
         def read_domain(output)
           if output =~ /.*?\.(.+$)/
             domain = Regexp.last_match(1)
-          elsif File.readable?('/etc/resolv.conf')
-            file = File.read('/etc/resolv.conf')
-            if file =~ /^search\s+(\S+)/
+          else
+            file_content = Util::FileHelper.safe_read('/etc/resolv.conf')
+            if file_content =~ /^search\s+(\S+)/
               domain = Regexp.last_match(1)
-            elsif file =~ /^domain\s+(\S+)/
+            elsif file_content =~ /^domain\s+(\S+)/
               domain = Regexp.last_match(1)
             end
           end

data/lib/resolvers/load_averages_resolver.rb

@@ -15,9 +15,7 @@ module Facter
           end
 
           def read_load_averages_file(fact_name)
-            return unless File.readable?('/proc/loadavg')
-
-            output = File.read('/proc/loadavg')
+            output = 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/resolvers/memory_resolver.rb

@@ -15,9 +15,9 @@ module Facter
           end
 
           def read_meminfo_file(fact_name)
-            return unless File.readable?('/proc/meminfo')
+            meminfo_output = Util::FileHelper.safe_read('/proc/meminfo', nil)
+            return unless meminfo_output
 
-            meminfo_output = File.read('/proc/meminfo')
             read_system(meminfo_output)
             read_swap(meminfo_output)
 

data/lib/resolvers/mountpoints_resolver.rb

@@ -16,9 +16,7 @@ module Facter
           end
 
           def root_device
-            return unless File.readable?('/proc/cmdline')
-
-            cmdline = File.read('/proc/cmdline')
+            cmdline = Util::FileHelper.safe_read('/proc/cmdline')
             match = cmdline.match(/root=([^\s]+)/)
             match&.captures&.first
           end

data/lib/resolvers/os_release_resolver.rb

@@ -25,15 +25,12 @@ module Facter
         end
 
         def read_os_release_file(fact_name)
-          unless File.readable?('/etc/os-release')
-            @fact_list[:name] = nil
-            return
-          end
+          output = Util::FileHelper.safe_readlines('/etc/os-release')
+          return @fact_list[:name] = nil if output.empty?
 
-          output = File.read('/etc/os-release')
           pairs = []
 
-          output.each_line do |line|
+          output.each do |line|
             pairs << line.strip.delete('"').split('=', 2)
           end
 

data/lib/resolvers/partitions.rb

@@ -6,6 +6,7 @@ module Facter
       @semaphore = Mutex.new
       @fact_list ||= {}
       BLOCK_PATH = '/sys/block'
+      BLOCK_SIZE = 512
 
       class << self
         private
@@ -41,23 +42,27 @@ module Facter
         end
 
         def extract_from_dm(block_path)
-          map_name = File.readable?("#{block_path}/dm/name") ? File.read("#{block_path}/dm/name").chomp : ''
+          map_name = Util::FileHelper.safe_read("#{block_path}/dm/name").chomp
           if map_name.empty?
-            populate_partitions("/dev/#{block_path}", block_path)
+            populate_partitions("/dev#{block_path}", block_path)
           else
             populate_partitions("/dev/mapper/#{map_name}", block_path)
           end
         end
 
         def extract_from_loop(block_path)
-          populate_partitions("/dev/#{block_path}", block_path) if File.readable?("#{block_path}/loop/backing_file")
-          backing_file = File.read("#{block_path}/loop/backing_file").chomp
-          populate_partitions("/dev/#{block_path}", block_path, backing_file)
+          backing_file = Util::FileHelper.safe_read("#{block_path}/loop/backing_file").chomp
+          if backing_file.empty?
+            populate_partitions("/dev#{block_path}", block_path)
+          else
+            populate_partitions("/dev#{block_path}", block_path, backing_file)
+          end
         end
 
         def populate_partitions(partition_name, block_path, backing_file = nil)
           @fact_list[:partitions][partition_name] = {}
-          size_bytes = File.readable?("#{block_path}/size") ? File.read("#{block_path}/size").chomp.to_i * 512 : 0
+          size_bytes = Util::FileHelper.safe_read("#{block_path}/size", '0')
+                                       .chomp.to_i * BLOCK_SIZE
           info_hash = { size_bytes: size_bytes,
                         size: Facter::BytesToHumanReadable.convert(size_bytes), backing_file: backing_file }
           info_hash.merge!(populate_from_blkid(partition_name))

data/lib/resolvers/processors_resolver.rb

@@ -19,9 +19,9 @@ module Facter
           end
 
           def read_cpuinfo(fact_name)
-            return unless File.readable?('/proc/cpuinfo')
+            cpuinfo_output = Util::FileHelper.safe_readlines('/proc/cpuinfo')
+            return if cpuinfo_output.empty?
 
-            cpuinfo_output = File.read('/proc/cpuinfo')
             read_processors(cpuinfo_output) # + model names
 
             @fact_list[:physical_count] = @fact_list[:physical_processors].uniq.length
@@ -32,7 +32,7 @@ module Facter
             @fact_list[:processors] = 0
             @fact_list[:models] = []
             @fact_list[:physical_processors] = []
-            cpuinfo_output.each_line do |line|
+            cpuinfo_output.each do |line|
               tokens = line.split(':')
               count_processors(tokens)
               construct_models_list(tokens)

data/lib/resolvers/selinux_resolver.rb

@@ -3,10 +3,6 @@
 module Facter
   module Resolvers
     class SELinux < BaseResolver
-      # :name
-      # :version
-      # :codename
-
       @semaphore = Mutex.new
       @fact_list ||= {}
 
@@ -19,7 +15,7 @@ module Facter
 
         def retrieve_facts(fact_name)
           mountpoint = read_mounts_file if @fact_list[:enabled].nil?
-          read_other_selinux_facts(mountpoint) if @fact_list[:enabled] && File.readable?('/etc/selinux/config')
+          read_other_selinux_facts(mountpoint) if @fact_list[:enabled]
 
           @fact_list[fact_name]
         end
@@ -40,14 +36,14 @@ module Facter
         end
 
         def read_other_selinux_facts(mountpoint)
-          read_selinux_config
+          return unless read_selinux_config
 
           enforce_file = "#{mountpoint}/enforce"
           policy_file = "#{mountpoint}/policyvers"
 
-          @fact_list[:policy_version] = File.read(policy_file) if File.readable?(policy_file)
+          @fact_list[:policy_version] = Util::FileHelper.safe_read(policy_file, nil)
 
-          enforce = File.read(enforce_file) if File.readable?(enforce_file)
+          enforce = Util::FileHelper.safe_read(enforce_file)
           if enforce.eql?('1')
             @fact_list[:enforced] = true
             @fact_list[:current_mode] = 'enforcing'
@@ -58,10 +54,14 @@ module Facter
         end
 
         def read_selinux_config
-          File.readlines('/etc/selinux/config').map do |line|
+          file_lines = Util::FileHelper.safe_readlines('/etc/selinux/config')
+
+          file_lines.map do |line|
             @fact_list[:config_mode] = line.split('=').last.strip if line =~ /^SELINUX=/
             @fact_list[:config_policy] = line.split('=').last.strip if line =~ /^SELINUXTYPE=/
           end
+
+          true unless file_lines.empty?
         end
       end
     end

data/lib/resolvers/solaris/filesystems_resolver.rb

@@ -15,7 +15,7 @@ module Facter
           end
 
           def read_sysdef_file(fact_name)
-            return unless File.readable?('/usr/sbin/sysdef')
+            return unless File.executable?('/usr/sbin/sysdef')
 
             file_content, _status = Open3.capture2('/usr/sbin/sysdef')
             files = file_content.split("\n").map do |line|

data/lib/resolvers/ssh_resolver.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'base64'
-require 'digest/sha1'
-
 module Facter
   module Resolvers
     class SshResolver < BaseResolver
@@ -24,52 +21,16 @@ module Facter
             next unless File.directory?(file_path)
 
             @file_names.each do |file_name|
-              next unless FileTest.file?(File.join(file_path, file_name))
+              file_content = Util::FileHelper.safe_read(File.join(file_path, file_name), nil)
+              next unless file_content
 
-              key_type, key = File.read(File.join(file_path, file_name)).split(' ')
-              key_name = determine_ssh_key_name(key_type)
-              ssh_list << create_ssh(key_name, key_type, key)
+              key_type, key = file_content.split(' ')
+              ssh_list << ::Resolvers::Utils::SshHelper.create_ssh(key_type, key)
             end
           end
           @fact_list[:ssh] = ssh_list
           @fact_list[fact_name]
         end
-
-        def create_ssh(key_name, key_type, key)
-          decoded_key = Base64.decode64(key)
-          ssh_fa = determine_ssh_fingerprint(key_name)
-          sha1 = "SSHFP #{ssh_fa} 1 #{Digest::SHA1.new.update(decoded_key)}"
-          sha256 = "SSHFP #{ssh_fa} 2 #{Digest::SHA2.new.update(decoded_key)}"
-
-          fingerprint = FingerPrint.new(sha1, sha256)
-          Ssh.new(fingerprint, key_type, key, key_name)
-        end
-
-        def determine_ssh_key_name(key)
-          case key
-          when 'ssh-dss'
-            'dsa'
-          when 'ecdsa-sha2-nistp256'
-            'ecdsa'
-          when 'ssh-ed25519'
-            'ed25519'
-          when 'ssh-rsa'
-            'rsa'
-          end
-        end
-
-        def determine_ssh_fingerprint(key_name)
-          case key_name
-          when 'rsa'
-            1
-          when 'dsa'
-            2
-          when 'ecdsa'
-            3
-          when 'ed25519'
-            4
-          end
-        end
       end
     end
   end

data/lib/resolvers/utils/ssh_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'digest/sha1'
+
+module Resolvers
+  module Utils
+    class SshHelper
+      class << self
+        SSH_NAME = { 'ssh-dss' => 'dsa', 'ecdsa-sha2-nistp256' => 'ecdsa',
+                     'ssh-ed25519' => 'ed25519', 'ssh-rsa' => 'rsa' }.freeze
+        SSH_FINGERPRINT = { 'rsa' => 1, 'dsa' => 2, 'ecdsa' => 3, 'ed25519' => 4 }.freeze
+
+        def create_ssh(key_type, key)
+          key_name = SSH_NAME[key_type]
+          decoded_key = Base64.decode64(key)
+          ssh_fp = SSH_FINGERPRINT[key_name]
+          sha1 = "SSHFP #{ssh_fp} 1 #{Digest::SHA1.new.update(decoded_key)}"
+          sha256 = "SSHFP #{ssh_fp} 2 #{Digest::SHA2.new.update(decoded_key)}"
+
+          fingerprint = Facter::FingerPrint.new(sha1, sha256)
+          Facter::Ssh.new(fingerprint, key_type, key, key_name)
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/windows/ssh.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Windows
+      class Ssh < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        FILE_NAMES = %w[ssh_host_rsa_key.pub ssh_host_dsa_key.pub
+                        ssh_host_ecdsa_key.pub ssh_host_ed25519_key.pub].freeze
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
+          end
+
+          def retrieve_info(fact_name)
+            ssh_dir = determine_ssh_dir
+            return unless ssh_dir && File.directory?(ssh_dir)
+
+            ssh_list = []
+
+            FILE_NAMES.each do |file_name|
+              output = Util::FileHelper.safe_read(File.join(ssh_dir, file_name))
+              next if output.empty?
+
+              key_type, key = output.split(' ')
+              ssh_list << ::Resolvers::Utils::SshHelper.create_ssh(key_type, key)
+            end
+            @fact_list[:ssh] = ssh_list.empty? ? nil : ssh_list
+            @fact_list[fact_name]
+          end
+
+          def determine_ssh_dir
+            progdata_dir = ENV['programdata']
+
+            return if !progdata_dir || progdata_dir.empty?
+
+            File.join(progdata_dir, 'ssh')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/util/file_helper.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facter
+  module Util
+    class FileHelper
+      @log = Log.new(self)
+      class << self
+        DEBUG_MESSAGE = 'File at: %s is not accessible.'
+
+        def safe_read(path, result_if_not_readable = '')
+          return File.read(path) if File.readable?(path)
+
+          result_if_not_readable
+        end
+
+        def safe_readlines(path, result_if_not_readable = [])
+          return File.readlines(path) if File.readable?(path)
+
+          result_if_not_readable
+        end
+      end
+    end
+  end
+end