facter 4.0.34 → 4.0.39

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/{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

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

@@ -7,7 +7,6 @@ module Facter
         BLOCKSIZE = 512
         # :system
         # :swap
-        @semaphore = Mutex.new
         @fact_list ||= {}
         class << self
           private

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

@@ -8,7 +8,6 @@ module Facter
     module Solaris
       class Networking < BaseResolver
         @log = Facter::Log.new(self)
-        @semaphore = Mutex.new
         @fact_list ||= {}
         @interfaces = {}
 

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Solaris
+      class OsRelease < BaseResolver
+        @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/processors.rb

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

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

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