facter 4.0.28

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

data/lib/resolvers/solaris/zone_resolver.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SolarisZone < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { build_zone_fact(fact_name) }
+        end
+
+        def build_zone_fact(fact_name)
+          command = '/usr/sbin/zoneadm list -cp'
+          zone_adm_output = Facter::Core::Execution.execute(command, logger: log)
+
+          if zone_adm_output.empty?
+            log.debug("Command #{command} returned an empty result")
+            return
+          end
+          @fact_list[:zone] = create_zone_facts(zone_adm_output)
+
+          @fact_list[fact_name]
+        end
+
+        def create_zone_facts(zones_result)
+          zones_fact = []
+          zones_result.each_line do |zone_line|
+            id, name, status, path, uuid, brand, ip_type = zone_line.split(':')
+            zones_fact << {
+              brand: brand,
+              id: id,
+              iptype: ip_type.chomp,
+              name: name,
+              uuid: uuid,
+              status: status,
+              path: path
+
+            }
+          end
+          zones_fact
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/solaris/zpool_resolver.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class ZPool < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { zpool_fact(fact_name) }
+          end
+
+          def zpool_fact(fact_name)
+            build_zpool_facts
+            @fact_list[fact_name]
+          end
+
+          def build_zpool_facts
+            output = Facter::Core::Execution.execute('zpool upgrade -v', logger: log)
+            features_list = output.scan(/^\s+(\d+)/).flatten
+            features_flags = output.scan(/^([a-z0-9_]+)[[:blank:]]*(\(read-only compatible\))?$/).map(&:first)
+
+            return if features_list.empty?
+
+            @fact_list[:zpool_featurenumbers] = features_list.join(',')
+            @fact_list[:zpool_featureflags] = features_flags.join(',')
+            @fact_list[:zpool_version] = features_flags.any? ? '5000' : features_list.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/ssh_resolver.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SshResolver < 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]
+      @file_paths = %w[/etc/ssh /usr/local/etc/ssh /etc /usr/local/etc /etc/opt/ssh]
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { retrieve_info(fact_name) }
+        end
+
+        def retrieve_info(fact_name)
+          ssh_list = []
+          @file_paths.each do |file_path|
+            next unless File.directory?(file_path)
+
+            @file_names.each do |file_name|
+              file_content = Util::FileHelper.safe_read(File.join(file_path, file_name), nil)
+              next unless file_content
+
+              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
+      end
+    end
+  end
+end

data/lib/resolvers/suse_release_resolver.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SuseRelease < BaseResolver
+      # :name
+      # :version
+      # :codename
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_suse_release(fact_name) }
+        end
+
+        def read_suse_release(fact_name)
+          output = Util::FileHelper.safe_read('/etc/SuSE-release', nil)
+          return @fact_list[fact_name] = nil if output.nil?
+
+          output_strings = output.split(' ')
+
+          @fact_list[:name] = output_strings[0]
+          @fact_list[:version] = output_strings[1]
+          @fact_list[:identifier] = @fact_list[:name].downcase
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end