facter 4.0.23

data/lib/resolvers/aix/nim.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Nim < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_niminfo(fact_name) }
+          end
+
+          def read_niminfo(fact_name)
+            output = Facter::Util::FileHelper.safe_read('/etc/niminfo', nil)
+
+            return unless output
+
+            type = /NIM_CONFIGURATION=(.*)/.match(output)
+            @fact_list[:type] = type[1] if type[1] && /master|standalone/.match?(type[1])
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/os_level_resolver.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class OsLevel < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_oslevel(fact_name) }
+        end
+
+        def read_oslevel(fact_name)
+          output = Facter::Core::Execution.execute('/usr/bin/oslevel -s', logger: log)
+          @fact_list[:build] = output
+          @fact_list[:kernel] = 'AIX'
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/partitions.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Partitions < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          MEGABYTES_EXPONENT = 1024**2
+          GIGABYTES_EXPONENT = 1024**3
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { query_cudv(fact_name) }
+          end
+
+          def query_cudv(fact_name)
+            @fact_list[:partitions] = {}
+
+            odmquery = Facter::ODMQuery.new
+            odmquery.equals('PdDvLn', 'logical_volume/lvsubclass/lvtype')
+
+            result = odmquery.execute
+
+            return unless result
+
+            result.each_line do |line|
+              next unless line.include?('name')
+
+              part_name = line.split('=')[1].strip.delete('"')
+              part = "/dev/#{part_name}"
+              info = populate_from_lslv(part_name)
+              @fact_list[:partitions][part] = info if info
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def populate_from_lslv(name)
+            stdout = Facter::Core::Execution.execute("lslv -L #{name}", logger: log)
+
+            return if stdout.empty?
+
+            info_hash = extract_info(stdout)
+            size_bytes = compute_size(info_hash)
+
+            part_info = {
+              filesystem: info_hash['TYPE'],
+              size_bytes: size_bytes,
+              size: Facter::FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
+            }
+            mount = info_hash['MOUNTPOINT']
+            label = info_hash['LABEL']
+            part_info[:mount] = mount unless %r{N/A} =~ mount
+            part_info[:label] = label unless /None/ =~ label
+            part_info
+          end
+
+          def extract_info(lsl_content)
+            lsl_content = lsl_content.strip.split("\n").map do |line|
+              next unless /PPs:|PP SIZE|TYPE:|LABEL:|MOUNT/ =~ line
+
+              line.split(/:|\s\s/).reject(&:empty?)
+            end
+
+            lsl_content.flatten!.select! { |elem| elem }.map! { |elem| elem.delete("\s") }
+
+            Hash[*lsl_content]
+          end
+
+          def compute_size(info_hash)
+            physical_partitions = info_hash['PPs'].to_i
+            size_physical_partition = info_hash['PPSIZE']
+            exp = size_physical_partition[/mega/] ? MEGABYTES_EXPONENT : GIGABYTES_EXPONENT
+            size_physical_partition.to_i * physical_partitions * exp
+          end
+        end
+      end
+    end
+  end
+end

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,25 @@
+# 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
+      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
+    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/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