openfact 5.0.0.rc0

data/lib/facter/resolvers/os_release.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class OsRelease < BaseResolver
+      # :pretty_name
+      # :name
+      # :version_id
+      # :version
+      # :id
+      # :id_like
+      # :ansi_color
+      # :home_url
+      # :support_url
+      # :bug_report_url
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) do
+            # If we get here multiple times per run it's probably because
+            # someone's asking for a os-release value not present in the file
+            # (e.g. VERSION is not a thing on rolling distributions, so this
+            # code will always run if the resolver is being asked for :version,
+            # because it'll never get cached).
+            #
+            # Just return early to avoid reparsing the file.
+            return unless @fact_list.empty?
+
+            pairs = read_and_parse_os_release_file
+            return unless pairs
+
+            fill_fact_list(pairs)
+
+            process_name
+            process_version_id
+            process_id
+
+            @fact_list[fact_name]
+          end
+        end
+
+        def read_and_parse_os_release_file
+          content = Facter::Util::FileHelper.safe_readlines('/etc/os-release')
+          return nil if content.empty?
+
+          pairs = []
+          content.each do |line|
+            pairs << line.strip.delete('"').split('=', 2) unless line.start_with?('#')
+          end
+
+          pairs
+        end
+
+        def fill_fact_list(pairs)
+          result = Hash[*pairs.flatten]
+          result.each { |k, v| @fact_list[k.downcase.to_sym] = v }
+        end
+
+        def process_version_id
+          return unless @fact_list[:version_id]
+
+          @fact_list[:version_id] = "#{@fact_list[:version_id]}.0" unless /\./.match?(@fact_list[:version_id])
+        end
+
+        def process_id
+          return unless @fact_list[:id]
+
+          @fact_list[:id] = 'sles' if /sles_sap/i.match?(@fact_list[:id])
+          @fact_list[:id] = 'opensuse' if /opensuse/i.match?(@fact_list[:id])
+        end
+
+        def process_name
+          return unless @fact_list[:name]
+
+          normalize_os_name
+          join_os_name
+          capitalize_os_name
+          append_linux_to_os_name
+        end
+
+        def normalize_os_name
+          os_name = @fact_list[:name]
+          @fact_list[:name] = if os_name.downcase.start_with?('sles')
+                                'SLES'
+                              else
+                                os_name
+                              end
+        end
+
+        def join_os_name
+          os_name = @fact_list[:name]
+          @fact_list[:name] = if os_name.downcase.start_with?('red', 'oracle', 'arch', 'manjaro')
+                                os_name = os_name.split(' ')[0..1].join
+                                os_name
+                              elsif os_name.downcase.end_with?('azure linux')
+                                os_name.split(' ')[1..2].join
+                              elsif os_name.downcase.end_with?('mariner')
+                                os_name.split(' ')[-1].strip
+                              else
+                                os_name.split(' ')[0].strip
+                              end
+        end
+
+        def capitalize_os_name
+          os_name = @fact_list[:name]
+          @fact_list[:name] = os_name.capitalize if os_name.downcase.start_with?('arch', 'manjaro')
+        end
+
+        def append_linux_to_os_name
+          os_name = @fact_list[:name]
+          @fact_list[:name] = "#{os_name}Linux" if os_name.downcase.start_with?('virtuozzo')
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/partitions.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Partitions < BaseResolver
+      init_resolver
+
+      BLOCK_PATH = '/sys/block'
+      BLOCK_SIZE = 512
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_partitions(fact_name) }
+        end
+
+        def read_partitions(fact_name)
+          return unless File.readable?(BLOCK_PATH)
+
+          block_devices = Dir.entries(BLOCK_PATH).reject { |dir| dir =~ /^\.+/ }
+          @fact_list[:partitions] = {} unless block_devices.empty?
+          blkid_and_lsblk = {}
+
+          block_devices.each do |block_device|
+            block_path = "#{BLOCK_PATH}/#{block_device}"
+            if File.directory?("#{block_path}/device")
+              extract_from_device(block_path, blkid_and_lsblk)
+            elsif File.directory?("#{block_path}/dm")
+              extract_from_dm(block_path, block_device, blkid_and_lsblk)
+            elsif File.directory?("#{block_path}/loop")
+              extract_from_loop(block_path, block_device, blkid_and_lsblk)
+            end
+          end
+
+          @fact_list[fact_name]
+        end
+
+        def extract_from_device(block_path, blkid_and_lsblk)
+          subdirs = browse_subdirectories(block_path)
+          subdirs.each do |subdir|
+            name = "/dev/#{subdir.split('/').last}"
+            populate_partitions(name, subdir, blkid_and_lsblk)
+          end
+        end
+
+        def extract_from_dm(block_path, block_device, blkid_and_lsblk)
+          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
+            populate_partitions("/dev/mapper/#{map_name}", block_path, blkid_and_lsblk)
+          end
+        end
+
+        def extract_from_loop(block_path, block_device, blkid_and_lsblk)
+          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
+            populate_partitions("/dev/#{block_device}", block_path, blkid_and_lsblk, backing_file)
+          end
+        end
+
+        def populate_partitions(partition_name, block_path, blkid_and_lsblk, backing_file = nil)
+          size_bytes = Facter::Util::FileHelper.safe_read("#{block_path}/size", '0')
+                                               .chomp.to_i * BLOCK_SIZE
+          info_hash = { size_bytes: 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.compact
+        end
+
+        def populate_from_syscalls(partition_name, blkid_and_lsblk)
+          # Prefer lsblk over blkid since lsblk does not require root, returns more information, and is recommended by blkid
+          part_info = populate_from_lsblk(partition_name, blkid_and_lsblk)
+
+          return populate_from_blkid(partition_name, blkid_and_lsblk) if part_info.empty?
+
+          part_info
+        end
+
+        def browse_subdirectories(path)
+          dirs = Dir[File.join(path, '**', '*')].select { |p| File.directory? p }
+          dirs.select { |subdir| subdir.split('/').last.include?(path.split('/').last) }.reject(&:nil?)
+        end
+
+        def populate_from_blkid(partition_name, blkid_and_lsblk)
+          return {} unless available?('blkid', blkid_and_lsblk)
+
+          blkid_and_lsblk[:blkid] ||= execute_and_extract_blkid_info
+
+          partition_data = blkid_and_lsblk[:blkid][partition_name]
+          return {} unless partition_data
+
+          filesys = partition_data['TYPE']
+          uuid = partition_data['UUID']
+          label = partition_data['LABEL']
+          part_uuid = partition_data['PARTUUID']
+          part_label = partition_data['PARTLABEL']
+
+          { filesystem: filesys, uuid: uuid, label: label, partuuid: part_uuid, partlabel: part_label }
+        end
+
+        def available?(command, blkid_and_lsblk)
+          command_exists_key = command == 'blkid' ? :blkid_exists : :lsblk_exists
+
+          return blkid_and_lsblk[command_exists_key] unless blkid_and_lsblk[command_exists_key].nil?
+
+          blkid_and_lsblk[command_exists_key] = !Facter::Core::Execution.which(command).nil?
+        end
+
+        def execute_and_extract_blkid_info
+          stdout = Facter::Core::Execution.execute('blkid', logger: log)
+          output_hash = Hash[*stdout.split(/^([^:]+):/)[1..-1]]
+          output_hash.each do |key, value|
+            output_hash[key] = Hash[*value.delete('"').chomp.rstrip.split(/ ([^= ]+)=/)[1..-1]]
+          end
+        end
+
+        def populate_from_lsblk(partition_name, blkid_and_lsblk)
+          return {} unless available?('lsblk', blkid_and_lsblk)
+
+          lsblk_version_raw = Facter::Core::Execution.execute('lsblk --version 2>&1', logger: log)
+          # Return if the version of lsblk is too old (< 2.22) to support the --version flag
+          lsblk_version_raw.match?(/ \d\.\d+/) ? lsblk_version = lsblk_version_raw.match(/ \d\.\d+/)[0].to_f : (return {})
+
+          # The -p/--paths option was added in lsblk 2.23, return early and fall back to blkid with earlier versions
+          return {} if lsblk_version < 2.23
+
+          blkid_and_lsblk[:lsblk] ||= execute_and_extract_lsblk_info(lsblk_version)
+
+          partition_data = blkid_and_lsblk[:lsblk][partition_name]
+          return {} unless partition_data
+
+          filesys = partition_data['FSTYPE']
+          uuid = partition_data['UUID']
+          label = partition_data['LABEL']
+          part_uuid = partition_data['PARTUUID']
+          part_label = partition_data['PARTLABEL']
+          part_type = partition_data['PARTTYPE']
+
+          result = { filesystem: filesys, uuid: uuid, label: label, partuuid: part_uuid, partlabel: part_label }
+          result[:parttype] = part_type if part_type
+
+          result
+        end
+
+        def execute_and_extract_lsblk_info(lsblk_version)
+          # lsblk 2.25 added support for GPT partition type GUIDs
+          stdout = if lsblk_version >= 2.25
+                     Facter::Core::Execution.execute('lsblk -p -P -o NAME,FSTYPE,UUID,LABEL,PARTUUID,PARTLABEL,PARTTYPE', logger: log)
+                   else
+                     Facter::Core::Execution.execute('lsblk -p -P -o NAME,FSTYPE,LABEL,UUID,PARTUUID,PARTLABEL', logger: log)
+                   end
+
+          output_hash = Hash[*stdout.split(/^(NAME=\S+)/)[1..-1]]
+          output_hash.transform_keys! { |key| key.delete('NAME=')[1..-2] }
+          output_hash.each do |key, value|
+            output_hash[key] = Hash[*value.chomp.rstrip.split(/ ([^= ]+)=/)[1..-1].each { |x| x.delete!('"') }]
+          end
+          output_hash.each_value { |value_hash| value_hash.delete_if { |_k, v| v.empty? } }
+          output_hash.delete_if { |_k, v| v.empty? }
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/path.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Path < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_path_from_env }
+        end
+
+        def read_path_from_env
+          @fact_list[:path] = ENV['PATH']
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/redhat_release.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class RedHatRelease < BaseResolver
+      # :name
+      # :version
+      # :codename
+      # :description
+      # :distributor_id
+
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_redhat_release(fact_name) }
+        end
+
+        def read_redhat_release(fact_name)
+          output = Facter::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)
+          @fact_list[:description] = output.strip
+          output_strings = output.split('release')
+          output_strings.map!(&:strip)
+
+          @fact_list[:codename] = codename(output)
+          @fact_list[:distributor_id] = distributor_id(output_strings[0])
+          @fact_list[:name] = release_name(output_strings[0])
+          @fact_list[:version] = version(output_strings)
+          @fact_list[:id] = id(@fact_list[:name])
+        end
+
+        def release_name(value)
+          value.split.reject { |el| el.casecmp('linux').zero? }[0..1].join
+        end
+
+        def id(value)
+          id = value.downcase
+          id = 'rhel' if @fact_list[:name].casecmp('Red Hat Enterprise Linux')
+
+          id
+        end
+
+        def codename(value)
+          matched_data = value.match(/.*release.*(\(.*\)).*/)
+          return unless matched_data
+
+          codename = (matched_data[1] || '').gsub(/\(|\)/, '')
+          codename.empty? ? nil : codename
+        end
+
+        def version(value)
+          value[1].split.first
+        end
+
+        def distributor_id(value)
+          value.split.reject { |el| el.casecmp('linux').zero? }.join
+        end
+      end
+    end
+  end
+end

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

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

data/lib/facter/resolvers/selinux.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class SELinux < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { retrieve_facts(fact_name) }
+        end
+
+        def retrieve_facts(fact_name)
+          mountpoint = selinux_mountpoint
+
+          @fact_list[:enabled] = !mountpoint.empty? && read_selinux_config
+          read_other_selinux_facts(mountpoint) if @fact_list[:enabled]
+
+          @fact_list[fact_name]
+        end
+
+        def selinux_mountpoint
+          output = Facter::Core::Execution.execute('cat /proc/self/mounts', logger: log)
+          mountpoint = ''
+
+          output.each_line do |line|
+            next unless /selinuxfs/.match?(line)
+
+            mountpoint = line.split("\s")[1]
+            break
+          end
+          mountpoint
+        end
+
+        def read_other_selinux_facts(mountpoint)
+          enforce_file = "#{mountpoint}/enforce"
+          policy_file = "#{mountpoint}/policyvers"
+
+          @fact_list[:policy_version] = Facter::Util::FileHelper.safe_read(policy_file, nil)
+
+          enforce = Facter::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 = Facter::Util::FileHelper.safe_readlines('/etc/selinux/config')
+
+          file_lines.map do |line|
+            @fact_list[:config_mode] = line.split('=').last.strip if /^SELINUX=/.match?(line)
+            @fact_list[:config_policy] = line.split('=').last.strip if /^SELINUXTYPE=/.match?(line)
+          end
+
+          !file_lines.empty? ? true : false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Disks < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_disks_info(fact_name) }
+          end
+
+          def read_disks_info(fact_name)
+            return unless File.executable?('/usr/bin/kstat')
+
+            log.debug('loading disks info')
+
+            kstat_output = Facter::Core::Execution.execute('/usr/bin/kstat sderr', logger: log)
+            return if kstat_output.empty?
+
+            @fact_list[fact_name] = parse(kstat_output)
+          end
+
+          def parse(kstat_output)
+            disks = {}
+
+            names = kstat_output.scan(/name:\s+(\w+)/).flatten
+            products = kstat_output.scan(/Product\s+(.+)/).flatten
+            vendors = kstat_output.scan(/Vendor\s+(\w+)/).flatten
+            sizes = kstat_output.scan(/Size\s+(\w+)/).flatten
+
+            names.each_with_index do |name, index|
+              disk_size = sizes[index].to_i
+              disks[name] = {
+                product: products[index],
+                size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(disk_size),
+                size_bytes: disk_size,
+                vendor: vendors[index]
+              }
+            end
+            disks
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Dmi < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          SMBIOS_PARAMS = {
+            'SMB_TYPE_BIOS' => {
+              bios_version: 'Version String: (.+)',
+              bios_vendor: 'Vendor: (.+)',
+              bios_release_date: 'Release Date: (.+)'
+            },
+            'SMB_TYPE_SYSTEM' => {
+              manufacturer: 'Manufacturer: (.+)',
+              product_name: 'Product: (.+)',
+              serial_number: 'Serial Number: (.+)',
+              product_uuid: 'UUID: (.+)'
+            },
+            'SMB_TYPE_CHASSIS' => {
+              chassis_asset_tag: 'Asset Tag: (.+)',
+              chassis_type: '(?:Chassis )?Type: (.+)'
+            }
+          }.freeze
+
+          def read_facts(fact_name)
+            param = SMBIOS_PARAMS.find { |_key, hash| hash[fact_name] }
+            return nil unless param
+
+            output = exec_smbios(param[0])
+            facts = param[1]
+            return unless output
+
+            facts.each do |name, regx|
+              @fact_list[name] = output.match(/#{regx}/)&.captures&.first
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def exec_smbios(args)
+            return unless File.executable?('/usr/sbin/smbios')
+
+            Facter::Core::Execution.execute("/usr/sbin/smbios -t #{args}", logger: log)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class DmiSparc < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            output = exec_prtdiag
+            return unless output
+
+            matches = output.match(/System Configuration:\s+(.+?)\s+sun\d+\S+\s+(.+)/)&.captures
+
+            # There are circumstances (e.g. in non-global zones) when prtdiag
+            # will return text, but it's an error message or some other string
+            # that isn't parsed by the above match/capture. In that case, we
+            # simply return.
+            return if matches.nil?
+
+            @fact_list[:manufacturer] = matches[0]&.strip
+            @fact_list[:product_name] = matches[1]&.strip
+
+            sneep = exec_sneep&.strip
+            @fact_list[:serial_number] = sneep
+
+            @fact_list[fact_name]
+          end
+
+          def exec_prtdiag
+            return unless File.executable?('/usr/sbin/prtdiag')
+
+            Facter::Core::Execution.execute('/usr/sbin/prtdiag', logger: log)
+          end
+
+          def exec_sneep
+            return unless File.executable?('/usr/sbin/sneep')
+
+            Facter::Core::Execution.execute('/usr/sbin/sneep', logger: log)
+          end
+        end
+      end
+    end
+  end
+end