facter 4.0.31 → 4.0.36

data/lib/facter/resolvers/redhat_release_resolver.rb

@@ -32,9 +32,10 @@ module Facter
           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[:version] = version_codename[0]&.strip
+
+          codename = version_codename[1]&.strip
+          @fact_list[:codename] = codename ? codename.gsub(/[()]/, '') : nil
 
           @fact_list[:identifier] = identifier(@fact_list[:name])
         end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Disks < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @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::FactsUtils::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,57 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Dmi < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @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]
+            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,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class DmiSparc < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @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
+
+            @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

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

@@ -20,6 +20,11 @@ module Facter
         INET_ADDRSTRLEN   = 16
         INET6_ADDRSTRLEN  = 46
       end
+
+      BINDINGS_KEY = {
+        FFI::AF_INET => :bindings,
+        FFI::AF_INET6 => :bindings6
+      }.freeze
     end
   end
 end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Ldom < BaseResolver
+        # :chassis_serial
+        # :control_domain
+        # :domain_name
+        # :domain_uuid
+        # :role_control
+        # :role_io
+        # :role_root
+        # :role_service
+        # :role_impl
+
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        VIRTINFO_MAPPING = {
+          chassis_serial: %w[DOMAINCHASSIS serialno],
+          control_domain: %w[DOMAINCONTROL name],
+          domain_name: %w[DOMAINNAME name],
+          domain_uuid: %w[DOMAINUUID uuid],
+          role_control: %w[DOMAINROLE control],
+          role_io: %w[DOMAINROLE io],
+          role_root: %w[DOMAINROLE root],
+          role_service: %w[DOMAINROLE service],
+          role_impl: %w[DOMAINROLE impl]
+        }.freeze
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { call_virtinfo(fact_name) }
+          end
+
+          def call_virtinfo(fact_name)
+            # return unless File.executable?('/usr/sbin/virtinfo')
+
+            virtinfo_output = Facter::Core::Execution.execute('/usr/sbin/virtinfo  -a  -p', logger: log)
+            return if virtinfo_output.empty?
+
+            output_hash = parse_output(virtinfo_output)
+            return if output_hash.empty?
+
+            VIRTINFO_MAPPING.each do |key, value|
+              @fact_list[key] = output_hash.dig(*value)&.strip
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def parse_output(output)
+            result = {}
+            output.each_line do |line|
+              next unless line.include? 'DOMAIN'
+
+              x = line.split('|')
+              result[x.shift] = x.map { |f| f.split('=') }.to_h
+            end
+
+            result
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Memory < BaseResolver
+        BLOCKSIZE = 512
+        # :system
+        # :swap
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { calculate_memory(fact_name) }
+          end
+
+          def calculate_memory(fact_name)
+            @fact_list = { system: sys, swap: swap }
+
+            @fact_list[fact_name]
+          end
+
+          def sys
+            sys = {}
+            output = Facter::Core::Execution.execute('/usr/bin/kstat -m unix -n system_pages', logger: log).strip
+            total, free = parse_sys_output(output)
+
+            return unless total || free
+
+            sys[:total_bytes] = total
+            sys[:available_bytes] = free
+            sys[:used_bytes] = total - free
+            sys[:capacity] = FilesystemHelper.compute_capacity(total - free, total)
+
+            sys
+          end
+
+          def swap
+            swap_hash = {}
+            output = Facter::Core::Execution.execute('/usr/sbin/swap -l', logger: log).strip
+            total, free = parse_swap_output(output)
+
+            swap_hash[:total_bytes] = total
+            swap_hash[:available_bytes] = free
+            swap_hash[:used_bytes] = total - free
+            swap_hash[:capacity] = FilesystemHelper.compute_capacity(total - free, total)
+
+            swap_hash if total != 0
+          end
+
+          def parse_sys_output(output)
+            kstats = output.scan(/(physmem|pagesfree)\s+(\d+)/)
+            kstats = kstats.to_h
+            return unless kstats['physmem'] || kstats['pagesfree']
+            return unless pagesize != 0
+
+            total = kstats['physmem'].to_i * pagesize
+            free = kstats['pagesfree'].to_i * pagesize
+
+            [total, free]
+          end
+
+          def parse_swap_output(output)
+            total = 0
+            free = 0
+
+            output.each_line do |line|
+              swap_sizes = line.match(/(\d+)\s+(\d+)$/)
+              next if swap_sizes.nil?
+
+              total += swap_sizes[1].to_i
+              free += swap_sizes[2].to_i
+            end
+            total *= BLOCKSIZE
+            free *= BLOCKSIZE
+
+            [total, free]
+          end
+
+          def pagesize
+            unless @fact_list[:pagesize]
+              @fact_list[:pagesize] = Facter::Core::Execution.execute('pagesize', logger: log).strip.to_i
+              log.debug("Pagesize: #{@fact_list[:pagesize]}")
+            end
+            @fact_list[:pagesize]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/solaris/{networking_resolver.rb → networking.rb}

@@ -12,11 +12,6 @@ module Facter
         @fact_list ||= {}
         @interfaces = {}
 
-        BINDINGS_KEY = {
-          FFI::AF_INET => :bindings,
-          FFI::AF_INET6 => :bindings6
-        }.freeze
-
         class << self
           private
 
@@ -141,7 +136,8 @@ module Facter
           end
 
           def add_dhcp(interface_name)
-            result = Facter::Core::Execution.execute("dhcpinfo -i #{interface_name} ServerID", logger: log)
+            dhcpinfo_command = Facter::Core::Execution.which('dhcpinfo') || '/sbin/dhcpinfo'
+            result = Facter::Core::Execution.execute("#{dhcpinfo_command} -i #{interface_name} ServerID", logger: log)
 
             @interfaces[interface_name][:dhcp] = result.chomp
           end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class OsRelease < 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
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Zone < 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
+end