facter 4.0.9.pre → 4.0.10.pre

data/lib/models/resolved_fact.rb

@@ -6,9 +6,13 @@ module Facter
     attr_accessor :user_query, :filter_tokens, :value
 
     def initialize(name, value = '', type = :core)
+      unless type =~ /core|legacy|custom/
+        raise ArgumentError, 'The type provided for fact is not legacy, core or custom!'
+      end
+
       @name = name
       @value = Utils.deep_stringify_keys(value)
-      type =~ /core|legacy/ ? @type = type : (raise ArgumentError, 'The type provided for fact is not legacy or core!')
+      @type = type
     end
 
     def legacy?

data/lib/resolvers/aix/filesystem_resolver.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Filesystem < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_vtf_file(fact_name) }
+          end
+
+          def read_vtf_file(fact_name)
+            return unless File.readable?('/etc/vfs')
+
+            file_content = File.readlines('/etc/vfs').map do |line|
+              next if line =~ /#|%/ # skip lines that are comments or defaultvfs line
+
+              line.split(' ').first
+            end
+
+            @fact_list[:file_systems] = file_content.compact.sort.join(',')
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/disk_resolver.rb

@@ -17,28 +17,36 @@ module Facter
           end
 
           def read_facts(fact_name)
-            @fact_list[:disks] = {}
             build_disks_hash
 
             FILE_PATHS.each do |key, file|
               @fact_list[:disks].each do |disk, value|
                 file_path = File.join(DIR, disk, file)
 
-                next unless File.exist?(file_path)
+                next unless File.readable?(file_path)
 
                 result = File.read(file_path).strip
 
                 # Linux always considers sectors to be 512 bytes long independently of the devices real block size.
-                value[key] = file =~ /size/ ? result.to_i * 512 : result
+                value[key] = file =~ /size/ ? construct_size(value, result) : result
               end
             end
 
+            @fact_list[:disks] = nil if @fact_list[:disks].empty?
             @fact_list[fact_name]
           end
 
           def build_disks_hash
+            @fact_list[:disks] = {}
             directories = Dir.entries(DIR).reject { |dir| dir =~ /\.+/ }
             directories.each { |disk| @fact_list[:disks].merge!(disk => {}) }
+            @fact_list[:disks].select! { |disk, _fact| File.readable?(File.join(DIR, disk, 'device')) }
+          end
+
+          def construct_size(facts, value)
+            value = value.to_i * 512
+            facts[:size_bytes] = value
+            facts[:size] = Facter::BytesToHumanReadable.convert(value)
           end
         end
       end

data/lib/resolvers/dmi_resolver.rb

@@ -35,7 +35,7 @@ module Facter
                        product_uuid]
             return unless File.directory?('/sys/class/dmi')
 
-            if files.include?(fact_name.to_s) && File.exist?("/sys/class/dmi/id/#{fact_name}")
+            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
               chassis_to_name(@fact_list[fact_name]) if fact_name == :chassis_type
 

data/lib/resolvers/filesystems_resolver.rb

@@ -16,6 +16,8 @@ module Facter
           end
 
           def read_filesystems(fact_name)
+            return unless File.readable?('/proc/filesystems')
+
             output = File.read('/proc/filesystems')
             filesystems = []
             output.each_line do |line|

data/lib/resolvers/fips_enabled_resolver.rb

@@ -16,7 +16,8 @@ module Facter
           end
 
           def read_fips_file(fact_name)
-            return @fact_list[fact_name] = false unless File.directory?('/proc/sys/crypto')
+            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')
             @fact_list[:fips_enabled] = file_output.strip == '1'

data/lib/resolvers/hostname_resolver.rb

@@ -30,7 +30,7 @@ module Facter
         def read_domain(output)
           if output =~ /.*?\.(.+$)/
             domain = Regexp.last_match(1)
-          elsif File.exist?('/etc/resolv.conf')
+          elsif File.readable?('/etc/resolv.conf')
             file = File.read('/etc/resolv.conf')
             if file =~ /^search\s+(\S+)/
               domain = Regexp.last_match(1)

data/lib/resolvers/load_averages_resolver.rb

@@ -15,6 +15,8 @@ module Facter
           end
 
           def read_load_averages_file(fact_name)
+            return unless File.readable?('/proc/loadavg')
+
             output = File.read('/proc/loadavg')
             @fact_list[:load_averages] = {}.tap { |h| h['1m'], h['5m'], h['15m'], = output.split.map(&:to_f) }
 

data/lib/resolvers/lsb_release_resolver.rb

@@ -3,30 +3,48 @@
 module Facter
   module Resolvers
     class LsbRelease < BaseResolver
+      # :lsb_version
       # :distributor_id
       # :description
       # :release
       # :codename
 
       @semaphore = Mutex.new
+      @log = Facter::Log.new(self)
       @fact_list ||= {}
 
       class << self
         private
 
         def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { read_lsb_release_file(fact_name) }
+          @fact_list.fetch(fact_name) { retrieve_facts(fact_name) }
         end
 
-        def read_lsb_release_file(fact_name)
-          output, _status = Open3.capture2('lsb_release -a')
-          release_info = output.delete("\t").split("\n").map { |e| e.split(':') }
+        def retrieve_facts(fact_name)
+          lsb_release_installed? if @fact_list[:lsb_release_installed].nil?
+          read_lsb_release_file if @fact_list[:lsb_release_installed]
+          @fact_list[fact_name]
+        end
+
+        def lsb_release_installed?
+          output, stderr, _status = Open3.capture3('which lsb_release')
+          @log.debug(stderr) unless stderr.empty?
+          @fact_list[:lsb_release_installed] = !output.empty?
+        end
+
+        def read_lsb_release_file
+          output, stderr, _status = Open3.capture3('lsb_release -a')
+          @log.debug(stderr) unless stderr.empty?
+          build_fact_list(output)
+        end
+
+        def build_fact_list(info)
+          release_info = info.delete("\t").split("\n").map { |e| e.split(':', 2) }
 
           result = Hash[*release_info.flatten]
           result.each { |k, v| @fact_list[k.downcase.gsub(/\s/, '_').to_sym] = v }
 
           @fact_list[:identifier] = @fact_list[:distributor_id]
-          @fact_list[fact_name]
         end
       end
     end

data/lib/resolvers/macosx/ipaddress_resolver.rb

@@ -18,10 +18,12 @@ module Facter
             ip = nil
             primary_interface = read_primary_interface
             unless primary_interface.nil?
+              @fact_list[:primary] = primary_interface
               output, _status = Open3.capture2("ipconfig getifaddr #{primary_interface}")
               ip = output.strip
             end
-            @fact_list[fact_name] = ip
+            find_all_interfaces
+            @fact_list[:ip] = ip
             @fact_list[fact_name]
           end
 
@@ -33,6 +35,17 @@ module Facter
             end
             iface
           end
+
+          def find_all_interfaces
+            output, _status = Open3.capture2('ifconfig -a 2>/dev/null')
+
+            data_hash = Hash[*output.split(/^([A-Za-z0-9_]+): /)[1..-1]]
+
+            macaddress = */ether (([0-9A-Fa-f]{2}[:-]){5}([0-9A-Fa-f]{2}))/.match(data_hash[@fact_list[:primary]])
+            @fact_list[:macaddress] = macaddress[1]
+
+            @fact_list[:interfaces] = data_hash.keys.join(',')
+          end
         end
       end
     end

data/lib/resolvers/memory_resolver.rb

@@ -15,6 +15,8 @@ module Facter
           end
 
           def read_meminfo_file(fact_name)
+            return unless File.readable?('/proc/meminfo')
+
             meminfo_output = File.read('/proc/meminfo')
             read_system(meminfo_output)
             read_swap(meminfo_output)

data/lib/resolvers/mountpoints_resolver.rb

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

data/lib/resolvers/networking_linux_resolver.rb

@@ -19,10 +19,16 @@ module Facter
 
           retrieve_default_interface_and_ip
           retrieve_interface_info
-
+          retrieve_macaddress
           @fact_list[fact_name]
         end
 
+        def retrieve_macaddress
+          output, _status = Open3.capture2("ip link show #{@fact_list[:primary_interface]}")
+          macaddress = */ether ([^ ]*) /.match(output)
+          @fact_list[:macaddress] = macaddress[1]
+        end
+
         def retrieve_interface_info
           output, _status = Open3.capture2('ip -o address')
           interfaces = {}

data/lib/resolvers/os_release_resolver.rb

@@ -25,7 +25,7 @@ module Facter
         end
 
         def read_os_release_file(fact_name)
-          unless File.exist?('/etc/os-release')
+          unless File.readable?('/etc/os-release')
             @fact_list[:name] = nil
             return
           end

data/lib/resolvers/processors_resolver.rb

@@ -19,6 +19,8 @@ module Facter
           end
 
           def read_cpuinfo(fact_name)
+            return unless File.readable?('/proc/cpuinfo')
+
             cpuinfo_output = File.read('/proc/cpuinfo')
             read_processors(cpuinfo_output) # + model names
 

data/lib/resolvers/puppet_version_resolver.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class PuppetVersionResolver < BaseResolver
+      # :puppetversion
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { puppet_version(fact_name) }
+        end
+
+        def puppet_version(fact_name)
+          require 'puppet/version'
+          @fact_list[:puppetversion] = Puppet.version
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/selinux_resolver.rb

@@ -14,22 +14,54 @@ module Facter
         private
 
         def post_resolve(fact_name)
-          @fact_list.fetch(fact_name) { read_lsb_release_file(fact_name) }
+          @fact_list.fetch(fact_name) { retrieve_facts(fact_name) }
         end
 
-        def read_lsb_release_file(fact_name)
+        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')
+
+          @fact_list[fact_name]
+        end
+
+        def read_mounts_file
           output, _s = Open3.capture2('cat /proc/self/mounts')
           @fact_list[:enabled] = false
+          mountpoint = ''
 
           output.each_line do |line|
             next unless line =~ /selinuxfs/
 
             @fact_list[:enabled] = true
-            @fact_list[:mountpoint] = line
+            mountpoint = line.split("\s")[1]
             break
           end
+          mountpoint
+        end
 
-          @fact_list[fact_name]
+        def read_other_selinux_facts(mountpoint)
+          read_selinux_config
+
+          enforce_file = "#{mountpoint}/enforce"
+          policy_file = "#{mountpoint}/policyvers"
+
+          @fact_list[:policy_version] = File.read(policy_file) if File.readable?(policy_file)
+
+          enforce = File.read(enforce_file) if File.readable?(enforce_file)
+          if enforce.eql?('1')
+            @fact_list[:enforced] = true
+            @fact_list[:current_mode] = 'enforcing'
+          else
+            @fact_list[:enforced] = false
+            @fact_list[:current_mode] = 'permissive'
+          end
+        end
+
+        def read_selinux_config
+          File.readlines('/etc/selinux/config').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
         end
       end
     end

data/lib/resolvers/solaris/filesystems_resolver.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Filesystem < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_sysdef_file(fact_name) }
+          end
+
+          def read_sysdef_file(fact_name)
+            return unless File.readable?('/usr/sbin/sysdef')
+
+            file_content, _status = Open3.capture2('/usr/sbin/sysdef')
+            files = file_content.split("\n").map do |line|
+              line.split('/').last if line =~ /^fs\.*/
+            end
+
+            @fact_list[:file_systems] = files.compact.sort.join(',')
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/solaris/zone_resolver.rb

@@ -14,7 +14,8 @@ module Facter
         end
 
         def build_zone_fact(fact_name)
-          zone_adm_output, status = Open3.capture2('/usr/sbin/zoneadm list -cp')
+          command = '/usr/sbin/zoneadm list -cp'
+          zone_adm_output, status = Open3.capture2(command)
           unless status.to_s.include?('exit 0')
             @log.debug("Command #{command} returned status: #{status}")
             return
@@ -32,17 +33,16 @@ module Facter
           zones_fact = []
           zones_result.each_line do |zone_line|
             id, name, status, path, uuid, brand, ip_type = zone_line.split(':')
-            zone_fact = {
+            zones_fact << {
               brand: brand,
               id: id,
-              ip_type: ip_type.chomp,
+              iptype: ip_type.chomp,
               name: name,
               uuid: uuid,
               status: status,
               path: path
 
             }
-            zones_fact << zone_fact
           end
           zones_fact
         end

data/lib/resolvers/ssh_resolver.rb

@@ -24,7 +24,7 @@ module Facter
             next unless File.directory?(file_path)
 
             @file_names.each do |file_name|
-              next unless File.file?(File.join(file_path, file_name))
+              next unless FileTest.file?(File.join(file_path, file_name))
 
               key_type, key = File.read(File.join(file_path, file_name)).split(' ')
               key_name = determine_ssh_key_name(key_type)