facter 4.0.32 → 4.0.37

data/lib/facter/resolvers/open_vz.rb

@@ -5,7 +5,6 @@ module Facter
     class OpenVz < BaseResolver
       # build
 
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/os_level_resolver.rb

@@ -5,7 +5,6 @@ module Facter
     class OsLevel < BaseResolver
       # build
 
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/os_release_resolver.rb

@@ -14,7 +14,6 @@ module Facter
       # :support_url
       # :bug_report_url
 
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self
@@ -56,7 +55,7 @@ module Facter
         def process_name
           return unless @fact_list[:name]
 
-          @fact_list[:name] = if @fact_list[:name].downcase.start_with?('red')
+          @fact_list[:name] = if @fact_list[:name].downcase.start_with?('red', 'oracle')
                                 @fact_list[:name].split(' ')[0..1].join
                               else
                                 @fact_list[:name].split(' ')[0].strip

data/lib/facter/resolvers/partitions.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class Partitions < BaseResolver
-      @semaphore = Mutex.new
       @fact_list ||= {}
       BLOCK_PATH = '/sys/block'
       BLOCK_SIZE = 512
@@ -66,10 +65,18 @@ module Facter
           info_hash = { size_bytes: size_bytes,
                         size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes),
                         backing_file: backing_file }
-          info_hash.merge!(populate_from_blkid(partition_name))
+          info_hash.merge!(populate_from_syscalls(partition_name))
           @fact_list[:partitions][partition_name] = info_hash.reject { |_key, value| value.nil? }
         end
 
+        def populate_from_syscalls(partition_name)
+          part_info = populate_from_blkid(partition_name)
+
+          return pupulate_from_lsblk(partition_name) if part_info.empty?
+
+          part_info
+        end
+
         def populate_from_blkid(partition_name)
           return {} unless blkid_command?
 
@@ -92,6 +99,34 @@ module Facter
           @blkid_exists = !output.empty?
         end
 
+        def pupulate_from_lsblk(partition_name)
+          return {} unless lsblk_command?
+
+          @lsblk_content ||= Facter::Core::Execution.execute('lsblk -fp', logger: log)
+
+          part_info = @lsblk_content.match(/#{partition_name}.*/).to_s.split(' ')
+          return {} if part_info.empty?
+
+          result = { filesystem: part_info[1] }
+
+          if part_info.count.eql?(5)
+            result[:label] = part_info[2]
+            result[:uuid] = part_info[3]
+          else
+            result[:uuid] = part_info[2]
+          end
+
+          result
+        end
+
+        def lsblk_command?
+          return @lsblk_exists unless @lsblk_exists.nil?
+
+          output = Facter::Core::Execution.execute('which lsblk', logger: log)
+
+          @lsblk_exists = !output.empty?
+        end
+
         def execute_and_extract_blkid_info
           stdout = Facter::Core::Execution.execute('blkid', logger: log)
           output_hash = Hash[*stdout.split(/^([^:]+):/)[1..-1]]

data/lib/facter/resolvers/path_resolver.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class Path < BaseResolver
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/processors_resolver.rb

@@ -5,12 +5,13 @@ module Facter
     module Linux
       class Processors < BaseResolver
         @log = Facter::Log.new(self)
-        @semaphore = Mutex.new
         @fact_list ||= {}
+        MHZ_TO_HZ = 1_000_000
         class << self
           # :count
           # :models
           # :physical_count
+          # :speed
 
           private
 
@@ -38,6 +39,7 @@ module Facter
               count_processors(tokens)
               construct_models_list(tokens)
               count_physical_processors(tokens)
+              build_speed(tokens)
             end
           end
 
@@ -46,7 +48,9 @@ module Facter
           end
 
           def construct_models_list(tokens)
-            @fact_list[:models] << tokens.last.strip if tokens.first.strip == 'model name'
+            return unless tokens.first.strip == 'model name' || tokens.first.strip == 'cpu'
+
+            @fact_list[:models] << tokens.last.strip
           end
 
           def count_physical_processors(tokens)
@@ -54,7 +58,24 @@ module Facter
           end
 
           def physical_devices_count
-            Dir.entries('/sys/devices/system/cpu').count { |dir| dir =~ /cpu[0-9]+$/ }
+            Dir.entries('/sys/devices/system/cpu')
+               .select { |dir| dir =~ /cpu[0-9]+$/ }
+               .count { |dir| File.exist?("/sys/devices/system/cpu/#{dir}/topology/physical_package_id") }
+          end
+
+          def build_speed(tokens)
+            build_speed_for_power_pc(tokens) if tokens.first.strip == 'clock'
+            build_speed_for_x86(tokens) if tokens.first.strip == 'cpu MHz'
+          end
+
+          def build_speed_for_power_pc(tokens)
+            speed = tokens.last.strip.match(/^(\d+).*MHz/)[1]
+            @fact_list[:speed] = speed.to_i * MHZ_TO_HZ
+          end
+
+          def build_speed_for_x86(tokens)
+            speed = tokens.last.strip.match(/^(\d+).*/)[1]
+            @fact_list[:speed] = speed.to_i * MHZ_TO_HZ
           end
         end
       end

data/lib/facter/resolvers/puppet_version_resolver.rb

@@ -5,7 +5,6 @@ module Facter
     class PuppetVersionResolver < BaseResolver
       # :puppetversion
 
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/redhat_release_resolver.rb

@@ -7,7 +7,6 @@ module Facter
       # :version
       # :codename
 
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/ruby_resolver.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class Ruby < BaseResolver
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

data/lib/facter/resolvers/selinux_resolver.rb

@@ -3,7 +3,6 @@
 module Facter
   module Resolvers
     class SELinux < BaseResolver
-      @semaphore = Mutex.new
       @fact_list ||= {}
 
       class << self

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Disks < BaseResolver
+        @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,56 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class Dmi < BaseResolver
+        @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,46 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class DmiSparc < BaseResolver
+        @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/{filesystems_resolver.rb → filesystems.rb}

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     module Solaris
       class Filesystem < BaseResolver
-        @semaphore = Mutex.new
         @fact_list ||= {}
 
         class << self

data/lib/facter/resolvers/solaris/{ipaddress_resolver.rb → ipaddress.rb}

@@ -4,7 +4,6 @@ module Facter
   module Resolvers
     module Solaris
       class Ipaddress < BaseResolver
-        @semaphore = Mutex.new
         @fact_list ||= {}
         class << self
           private

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

@@ -0,0 +1,69 @@
+# 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
+
+        @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