facter 4.0.23

data/lib/resolvers/processors_resolver.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Processors < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          # :count
+          # :models
+          # :physical_count
+
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_cpuinfo(fact_name) }
+          end
+
+          def read_cpuinfo(fact_name)
+            cpuinfo_output = Util::FileHelper.safe_readlines('/proc/cpuinfo')
+            return if cpuinfo_output.empty?
+
+            read_processors(cpuinfo_output) # + model names
+
+            @fact_list[:physical_count] = @fact_list[:physical_processors].uniq.length
+            @fact_list[:physical_count] = physical_devices_count if @fact_list[:physical_count].zero?
+            @fact_list[fact_name]
+          end
+
+          def read_processors(cpuinfo_output)
+            @fact_list[:processors] = 0
+            @fact_list[:models] = []
+            @fact_list[:physical_processors] = []
+            cpuinfo_output.each do |line|
+              tokens = line.split(':')
+              count_processors(tokens)
+              construct_models_list(tokens)
+              count_physical_processors(tokens)
+            end
+          end
+
+          def count_processors(tokens)
+            @fact_list[:processors] += 1 if tokens.first.strip == 'processor'
+          end
+
+          def construct_models_list(tokens)
+            @fact_list[:models] << tokens.last.strip if tokens.first.strip == 'model name'
+          end
+
+          def count_physical_processors(tokens)
+            @fact_list[:physical_processors] << tokens.last.strip.to_i if tokens.first.strip == 'physical id'
+          end
+
+          def physical_devices_count
+            Dir.entries('/sys/devices/system/cpu').count { |dir| dir =~ /cpu[0-9]+$/ }
+          end
+        end
+      end
+    end
+  end
+end

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/redhat_release_resolver.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class RedHatRelease < BaseResolver
+      # :name
+      # :version
+      # :codename
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @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)
+          return @fact_list[fact_name] = nil if output.nil?
+
+          build_fact_list(output)
+
+          @fact_list[fact_name]
+        end
+
+        def build_fact_list(output)
+          output_strings = output.split('release')
+          output_strings.map!(&:strip)
+          version_codename = output_strings[1].split(' ')
+
+          @fact_list[:name] = name(output_strings[0])
+          @fact_list[:version] = version_codename[0].strip
+          codename = version_codename[1].strip
+          @fact_list[:codename] = codename.gsub(/[()]/, '')
+
+          @fact_list[:identifier] = identifier(@fact_list[:name])
+        end
+
+        def name(name)
+          name.strip.split(' ')[0..1].join
+        end
+
+        def identifier(name)
+          identifier = name.strip.downcase
+          identifier = 'rhel' if @fact_list[:name].strip.casecmp('Red Hat Enterprise Linux')
+
+          identifier
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/ruby_resolver.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Ruby < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_ruby_information(fact_name) }
+        end
+
+        def retrieve_ruby_information(fact_name)
+          @fact_list[:sitedir] = RbConfig::CONFIG['sitelibdir']
+          @fact_list[:platform] = RUBY_PLATFORM
+          @fact_list[:version] = RUBY_VERSION
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/selinux_resolver.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SELinux < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_facts(fact_name) }
+        end
+
+        def retrieve_facts(fact_name)
+          mountpoint = read_mounts_file if @fact_list[:enabled].nil?
+          read_other_selinux_facts(mountpoint) if @fact_list[:enabled]
+
+          @fact_list[fact_name]
+        end
+
+        def read_mounts_file
+          output = Facter::Core::Execution.execute('cat /proc/self/mounts', logger: log)
+          @fact_list[:enabled] = false
+          mountpoint = ''
+
+          output.each_line do |line|
+            next unless line =~ /selinuxfs/
+
+            @fact_list[:enabled] = true
+            mountpoint = line.split("\s")[1]
+            break
+          end
+          mountpoint
+        end
+
+        def read_other_selinux_facts(mountpoint)
+          return unless read_selinux_config
+
+          enforce_file = "#{mountpoint}/enforce"
+          policy_file = "#{mountpoint}/policyvers"
+
+          @fact_list[:policy_version] = Util::FileHelper.safe_read(policy_file, nil)
+
+          enforce = Util::FileHelper.safe_read(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_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
+  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.executable?('/usr/sbin/sysdef')
+
+            file_content = Facter::Core::Execution.execute('/usr/sbin/sysdef', logger: log)
+            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/ipaddress_resolver.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Ipaddress < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_ipaddress(fact_name) }
+          end
+
+          def read_ipaddress(fact_name)
+            ip = nil
+            primary_interface = read_primary_interface
+            unless primary_interface.nil?
+              output = Facter::Core::Execution.execute("ifconfig #{primary_interface}", logger: log)
+              output.each_line do |str|
+                if str.strip =~ /inet\s(\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}) .+/
+                  @fact_list[:ip] = ip = Regexp.last_match(1)
+                  break
+                end
+              end
+            end
+            @fact_list[fact_name]
+          end
+
+          def read_primary_interface
+            output = Facter::Core::Execution.execute('route -n get default | grep interface', logger: log)
+            output.strip =~ /interface:\s(\S+)/ ? Regexp.last_match(1) : nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/solaris/processors.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Processors < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { collect_kstat_info(fact_name) }
+          end
+
+          def collect_kstat_info(fact_name)
+            return unless File.executable?('/usr/bin/kstat')
+
+            kstat_output = Facter::Core::Execution.execute('/usr/bin/kstat -m cpu_info', logger: log)
+            return if kstat_output.empty?
+
+            parse_output(kstat_output.chomp)
+            @fact_list[fact_name]
+          end
+
+          def parse_output(output)
+            @fact_list[:logical_count] = output.scan(/module/).size
+            @fact_list[:physical_count] = output.scan(/chip_id .*/).uniq.size
+            @fact_list[:speed] = output.scan(/current_clock_Hz .*/).first.gsub(/[a-zA-z\s]+/, '').to_i
+            @fact_list[:models] = output.scan(/brand .*/).map { |elem| elem.gsub(/brand(\s+)/, '') }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/solaris/solaris_os_release_resolver.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SolarisRelease < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      @os_version_regex_patterns = ['Solaris \d+ \d+/\d+ s(\d+)[sx]?_u(\d+)wos_',
+                                    'Solaris (\d+)[.](\d+)', 'Solaris (\d+)']
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { build_release_facts(fact_name) }
+        end
+
+        def build_release_facts(fact_name)
+          result = Util::FileHelper.safe_read('/etc/release', nil)
+          return @fact_list[fact_name] = nil if result.nil?
+
+          @os_version_regex_patterns.each do |os_version_regex|
+            major, minor = search_for_os_version(/#{os_version_regex}/, result)
+            next unless major || minor
+
+            @fact_list[:major] = major
+            @fact_list[:minor] = minor
+            @fact_list[:full] = major == '10' ? major + '_u' + minor : major + '.' + minor
+            break
+          end
+          @fact_list[fact_name]
+        end
+
+        def search_for_os_version(regex_pattern, text)
+          result = text.match(regex_pattern)
+          major, minor = result.captures if result
+          minor = regex_pattern == /Solaris (\d+)/ ? '0' : minor
+          return [major, minor] if major && minor
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/solaris/solaris_zone_name.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SolarisZoneName < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { build_current_zone_name_fact(fact_name) }
+        end
+
+        def build_current_zone_name_fact(fact_name)
+          zone_name_output = Facter::Core::Execution.execute('/bin/zonename', logger: log)
+
+          if zone_name_output.empty?
+            log.debug("Command #{command} returned an empty result")
+            return
+          end
+          @fact_list[:current_zone_name] = zone_name_output.chomp
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/solaris/zfs_resolver.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class ZFS < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { zfs_fact(fact_name) }
+          end
+
+          def zfs_fact(fact_name)
+            build_zfs_facts
+            @fact_list[fact_name]
+          end
+
+          def build_zfs_facts
+            output = Facter::Core::Execution.execute('zfs upgrade -v', logger: log)
+            features_list = output.scan(/^\s+(\d+)/).flatten
+
+            return if features_list.empty?
+
+            @fact_list[:zfs_featurenumbers] = features_list.join(',')
+            @fact_list[:zfs_version] = features_list.last
+          end
+        end
+      end
+    end
+  end
+end