facter 4.0.28

data/lib/resolvers/aix/processors.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Processors < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { query_pddv(fact_name) }
+          end
+
+          def query_pddv(fact_name)
+            @fact_list[:models] = []
+            @fact_list[:logical_count] = 0
+
+            odmquery = Facter::ODMQuery.new
+            odmquery.equals('class', 'processor')
+
+            result = odmquery.execute
+
+            return unless result
+
+            proc_names = retrieve_from_array(result.scan(/uniquetype\s=\s.*/), 1)
+
+            proc_names.each { |name| populate_from_cudv(name) }
+
+            @fact_list[fact_name]
+          end
+
+          def populate_from_cudv(name)
+            odmquery = Facter::ODMQuery.new
+            odmquery.equals('PdDvLn', name)
+
+            result = odmquery.execute
+
+            return unless result
+
+            names = retrieve_from_array(result.scan(/name\s=\s.*/), 1)
+
+            names.each { |elem| query_cuat(elem) }
+          end
+
+          def query_cuat(name)
+            odmquery = Facter::ODMQuery.new
+            odmquery.equals('name', name)
+
+            result = odmquery.execute
+
+            return unless result
+
+            type, frequency, smt_threads, smt_enabled = process(result)
+
+            @fact_list[:speed] ||= frequency if frequency
+
+            threads = smt_enabled ? smt_threads : 1
+
+            @fact_list[:logical_count] += threads
+            @fact_list[:models].concat([type] * threads)
+          end
+
+          def process(stdout)
+            type = retrieve_from_array(stdout.scan(/attribute\s=\s"type"\n\s+value\s=\s.*/), 2).first
+            frequency = retrieve_from_array(stdout.scan(/attribute\s=\s"frequency"\n\s+value\s=\s.*/), 2).first
+            smt_threads = retrieve_from_array(stdout.scan(/attribute\s=\s"smt_threads"\n\s+value\s=\s.*/), 2).first
+            smt_enabled = retrieve_from_array(stdout.scan(/attribute\s=\s"smt_enabled"\n\s+value\s=\s.*/), 2).first
+            [type, frequency.to_i, smt_threads.to_i, smt_enabled]
+          end
+
+          def retrieve_from_array(array, pos)
+            array.map { |elem| elem.split('=')[pos].strip.delete('"') }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/utils/odm_query.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+# CuAt (Customized Attributes) non-default attribute values
+# CuDv (Customized Devices) the devices present on this machine
+# PdAt (Predefined Attributes) default values for all device attributes
+# PdDv (Predefined Devices) the list of all devices supported by this release of AIX
+
+module Facter
+  class ODMQuery
+    REPOS = %w[CuAt CuDv PdAt PdDv].freeze
+
+    def initialize
+      @query = ''
+      @conditions = []
+      @log = Facter::Log.new(self)
+    end
+
+    def equals(field, value)
+      @conditions << "#{field}='#{value}'"
+      self
+    end
+
+    def like(field, value)
+      @conditions << "#{field} like '#{value}'"
+      self
+    end
+
+    def execute
+      result = nil
+      REPOS.each do |repo|
+        break if result && !result.empty?
+
+        result = Facter::Core::Execution.execute("#{query} #{repo}", logger: @log)
+      end
+      result
+    end
+
+    def query
+      'odmget -q "' + @conditions.join(' AND ') + '"'
+    end
+  end
+end

data/lib/resolvers/augeas_resolver.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Augeas < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_augeas_version(fact_name) }
+        end
+
+        def read_augeas_version(fact_name)
+          output = Facter::Core::Execution.execute('augparse --version 2>&1', logger: log)
+          @fact_list[:augeas_version] = Regexp.last_match(1) if output =~ /^augparse (\d+\.\d+\.\d+)/
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/base_resolver.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class BaseResolver
+      def self.log
+        @log ||= Log.new(self)
+      end
+
+      def self.invalidate_cache
+        @fact_list = {}
+      end
+
+      def self.subscribe_to_manager
+        Facter::SessionCache.subscribe(self)
+      end
+
+      def self.resolve(fact_name)
+        @semaphore.synchronize do
+          subscribe_to_manager
+          post_resolve(fact_name)
+        end
+      rescue LoadError => e
+        log.debug("resolving fact #{fact_name}, but #{e}")
+        @fact_list[fact_name] = nil
+      end
+
+      def self.post_resolve(_fact_name)
+        raise NotImplementedError, "You must implement post_resolve(fact_name) method in #{name}"
+      end
+    end
+  end
+end

data/lib/resolvers/bsd/ffi/ffi_helper.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Bsd
+    module FfiHelper
+      module Libc
+        extend FFI::Library
+
+        ffi_lib 'c'
+        attach_function :getloadavg, %i[pointer int], :int
+        attach_function :sysctl, %i[pointer uint pointer pointer pointer size_t], :int
+      end
+
+      def self.read_load_averages
+        raw_loadavg = FFI::MemoryPointer.new(:double, 3)
+
+        res = Libc.getloadavg(raw_loadavg, 3)
+        return unless res == 3
+
+        raw_loadavg.read_array_of_double(res)
+      end
+
+      def self.sysctl(type, oids)
+        name = FFI::MemoryPointer.new(:uint, oids.size)
+        name.write_array_of_uint(oids)
+        namelen = oids.size
+
+        oldp = FFI::Pointer::NULL
+        oldlenp = FFI::MemoryPointer.new(:size_t)
+
+        newp = FFI::Pointer::NULL
+        newlen = 0
+
+        if type == :string
+          res = Libc.sysctl(name, namelen, oldp, oldlenp, newp, newlen)
+          return nil if res.negative?
+        else
+          oldlenp.write(:size_t, FFI.type_size(type))
+        end
+
+        oldp = FFI::MemoryPointer.new(:uint8_t, oldlenp.read(:size_t))
+        res = Libc.sysctl(name, namelen, oldp, oldlenp, newp, newlen)
+        return nil if res.negative?
+
+        case type
+        when :string
+          oldp.read_string
+        else
+          oldp.read(type)
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/bsd/load_averages_resolver.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Bsd
+      class LoadAverages < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_load_averages(fact_name) }
+          end
+
+          def read_load_averages(fact_name)
+            require_relative 'ffi/ffi_helper'
+            @fact_list[:load_averages] = %w[1m 5m 15m].zip(Facter::Bsd::FfiHelper.read_load_averages).to_h
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/bsd/processors.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Bsd
+      class Processors < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { collect_processors_info(fact_name) }
+          end
+
+          def collect_processors_info(fact_name)
+            require "#{ROOT_DIR}/lib/resolvers/bsd/ffi/ffi_helper"
+
+            @fact_list[:logical_count] = logical_count
+            @fact_list[:models] = Array.new(logical_count, model) if logical_count && model
+            @fact_list[:speed] = speed * 1000 * 1000 if speed
+
+            @fact_list[fact_name]
+          end
+
+          CTL_HW = 6
+          HW_MODEL = 2
+          HW_NCPU = 3
+          HW_CPUSPEED = 12
+
+          def model
+            @model ||= Facter::Bsd::FfiHelper.sysctl(:string, [CTL_HW, HW_MODEL])
+          end
+
+          def logical_count
+            @logical_count ||= Facter::Bsd::FfiHelper.sysctl(:uint32_t, [CTL_HW, HW_NCPU])
+          end
+
+          def speed
+            @speed ||= Facter::Bsd::FfiHelper.sysctl(:uint32_t, [CTL_HW, HW_CPUSPEED])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/debian_version.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class DebianVersion < BaseResolver
+      # :major
+      # :minor
+      # :full
+
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_debian_version(fact_name) }
+        end
+
+        def read_debian_version(fact_name)
+          file_content = Util::FileHelper.safe_read('/etc/debian_version')
+          @fact_list[:version] = file_content.strip unless file_content.empty?
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/disk_resolver.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class Disk < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        DIR = '/sys/block'
+        FILE_PATHS = { model: 'device/model', size: 'size', vendor: 'device/vendor' }.freeze
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            build_disks_hash
+
+            FILE_PATHS.each do |key, file|
+              @fact_list[:disks].each do |disk, value|
+                file_path = File.join(DIR, disk, file)
+
+                result = Util::FileHelper.safe_read(file_path).strip
+                next if result.empty?
+
+                # Linux always considers sectors to be 512 bytes long independently of the devices real block size.
+                value[key] = file =~ /size/ ? construct_size(value, result) : result
+              end
+            end
+
+            @fact_list[:disks] = nil if @fact_list[:disks].empty?
+            @fact_list[fact_name]
+          end
+
+          def build_disks_hash
+            @fact_list[:disks] = {}
+            directories = Dir.entries(DIR).reject { |dir| dir =~ /\.+/ }
+            directories.each { |disk| @fact_list[:disks].merge!(disk => {}) }
+            @fact_list[:disks].select! { |disk, _fact| File.readable?(File.join(DIR, disk, 'device')) }
+          end
+
+          def construct_size(facts, value)
+            value = value.to_i * 512
+            facts[:size_bytes] = value
+            facts[:size] = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/dmi_resolver.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Linux
+      class DmiBios < BaseResolver
+        @log = Facter::Log.new(self)
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          # :bios_vendor
+          # :bios_date
+          # :bios_version
+          # :board_vendor
+          # :board_serial
+          # :board_name
+          # :chassis_asset_tag
+          # :chassis_type
+          # :sys_vendor
+          # :product_serial
+          # :product_name
+          # :product_uuid
+
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_facts(fact_name) }
+          end
+
+          def read_facts(fact_name)
+            files = %w[bios_date bios_vendor bios_version board_vendor board_name board_serial
+                       chassis_asset_tag chassis_type sys_vendor product_name product_serial
+                       product_uuid]
+            return unless File.directory?('/sys/class/dmi')
+
+            file_content = Util::FileHelper.safe_read("/sys/class/dmi/id/#{fact_name}", nil)
+            if files.include?(fact_name.to_s) && file_content
+              @fact_list[fact_name] = file_content.strip
+              chassis_to_name(@fact_list[fact_name]) if fact_name == :chassis_type
+
+            end
+            @fact_list[fact_name]
+          end
+
+          def chassis_to_name(chassis_type)
+            types = ['Other', nil, 'Desktop', 'Low Profile Desktop', 'Pizza Box', 'Mini Tower', 'Tower',
+                     'Portable', 'Laptop', 'Notebook', 'Hand Held', 'Docking Station', 'All in One', 'Sub Notebook',
+                     'Space-Saving', 'Lunch Box', 'Main System Chassis', 'Expansion Chassis', 'SubChassis',
+                     'Bus Expansion Chassis', 'Peripheral Chassis', 'Storage Chassis', 'Rack Mount Chassis',
+                     'Sealed-Case PC', 'Multi-system', 'CompactPCI', 'AdvancedTCA', 'Blade', 'Blade Enclosure',
+                     'Tablet', 'Convertible', 'Detachable']
+            @fact_list[:chassis_type] = types[chassis_type.to_i - 1]
+          end
+        end
+      end
+    end
+  end
+end