openfact 5.0.0.rc0

data/lib/facter/models/resolved_fact.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Facter
+  class ResolvedFact
+    attr_reader :name, :type
+    attr_accessor :user_query, :value, :file
+
+    def initialize(name, value = '', type = :core, user_query = nil)
+      @name = name
+      @value = Utils.deep_stringify_keys(value)
+      @type = type
+      @user_query = user_query
+    end
+
+    def legacy?
+      type == :legacy
+    end
+
+    def core?
+      type == :core
+    end
+
+    def to_s
+      @value.to_s
+    end
+
+    def resolves?(user_query)
+      @name == user_query
+    end
+  end
+end

data/lib/facter/models/searched_fact.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Facter
+  class SearchedFact
+    attr_reader :name, :fact_class, :user_query, :type
+    attr_accessor :file
+
+    def initialize(fact_name, fact_class, user_query, type)
+      @name = fact_name
+      @fact_class = fact_class
+      @user_query = user_query
+      @type = type
+    end
+  end
+end

data/lib/facter/resolvers/aio_agent_version.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class AioAgentVersion < BaseResolver
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_agent_version }
+        end
+
+        def read_agent_version
+          aio_agent_version = Facter::Util::FileHelper.safe_read('/opt/puppetlabs/puppet/VERSION', nil)&.chomp
+          aio_agent_version = aio_agent_version&.match(/^\d+\.\d+\.\d+(\.\d+){0,2}/)&.to_s
+          @fact_list[:aio_agent_version] = aio_agent_version
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/aix/architecture.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Architecture < BaseResolver
+      # :architecture
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_architecture(fact_name) }
+        end
+
+        def read_architecture(fact_name)
+          require_relative '../../../facter/util/aix/odm_query'
+
+          proc_number = read_proc
+          odmquery = Facter::Util::Aix::ODMQuery.new
+          odmquery
+            .equals('name', proc_number)
+            .equals('attribute', 'type')
+
+          result = odmquery.execute
+
+          return unless result
+
+          result.each_line do |line|
+            if line.include?('value')
+              @fact_list[:architecture] = line.split('=')[1].strip.delete('\"')
+              break
+            end
+          end
+
+          @fact_list[fact_name]
+        end
+
+        def read_proc
+          odmquery = Facter::Util::Aix::ODMQuery.new
+          odmquery
+            .equals('PdDvLn', 'processor/sys/proc_rspc')
+            .equals('status', '1')
+
+          result = odmquery.execute
+          result.each_line do |line|
+            return line.split('=')[1].strip.delete('\"') if line.include?('name')
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Disks < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { execute_lspv(fact_name) }
+          end
+
+          def execute_lspv(fact_name)
+            result = Facter::Core::Execution.execute('lspv', logger: log)
+
+            return if result.empty?
+
+            @fact_list[:disks] = {}
+
+            result.each_line do |line|
+              disk_name = line.split(' ')[0].strip
+              size = find_size(disk_name)
+              @fact_list[:disks][disk_name] = size if size
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def find_size(name)
+            stdout = Facter::Core::Execution.execute("lspv #{name}", logger: log)
+
+            return if stdout.empty?
+
+            info_size = Facter::Util::Aix::InfoExtractor.extract(stdout, :lspv)
+
+            return unless info_size['PV STATE']
+
+            size_bytes = compute_size(info_size)
+
+            {
+              size_bytes: size_bytes,
+              size: Facter::Util::Facts::UnitConverter.bytes_to_human_readable(size_bytes)
+            }
+          end
+
+          def compute_size(size_hash)
+            physical_partitions = size_hash['TOTAL PPs'].to_i
+            size_physical_partition = size_hash['PP SIZE']
+            exp = if size_physical_partition[/mega/]
+                    Facter::Util::Aix::InfoExtractor::MEGABYTES_EXPONENT
+                  else
+                    Facter::Util::Aix::InfoExtractor::GIGABYTES_EXPONENT
+                  end
+            size_physical_partition.to_i * physical_partitions * exp
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      module FFI
+        RTM_IFINFO = 0xe
+        RTM_NEWADDR = 0xc
+
+        RTAX_DST = 0
+        RTAX_GATEWAY = 1
+        RTAX_NETMASK = 2
+        RTAX_GENMASK = 3
+        RTAX_IFP = 4
+        RTAX_IFA = 5
+        RTAX_AUTHOR = 6
+        RTAX_BRD = 7
+        RTAX_MAX = 8
+
+        RTA_DST = 0x1
+        RTA_GATEWAY = 0x2
+        RTA_NETMASK = 0x4
+        RTA_GENMASK = 0x8
+        RTA_IFP = 0x10
+        RTA_IFA = 0x20
+        RTA_AUTHOR = 0x40
+        RTA_BRD = 0x80
+        RTA_DOWNSTREAM = 0x100
+
+        AF_UNSPEC = 0
+        AF_INET = 2
+        AF_INET6 = 24
+        AF_MAX = 30
+
+        INET_ADDRSTRLEN = 16
+        INET6_ADDRSTRLEN = 46
+
+        RTAX_LIST = [
+          RTAX_DST,
+          RTAX_GATEWAY,
+          RTAX_NETMASK,
+          RTAX_GENMASK,
+          RTAX_IFP,
+          RTAX_IFA,
+          RTAX_AUTHOR,
+          RTAX_BRD
+        ].freeze
+
+        RTA_LIST = [
+          RTA_DST,
+          RTA_GATEWAY,
+          RTA_NETMASK,
+          RTA_GENMASK,
+          RTA_IFP,
+          RTA_IFA,
+          RTA_AUTHOR,
+          RTA_BRD,
+          RTA_DOWNSTREAM
+        ].freeze
+      end
+    end
+  end
+end

data/lib/facter/resolvers/aix/ffi/ffi_helper.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'ffi'
+require_relative 'structs'
+require_relative 'ffi'
+module Facter
+  module Resolvers
+    module Aix
+      module FfiHelper
+        KINFO_GET_AVENRUN = 1
+        KINFO_READ        = 8 << 8
+        KINFO_RT          = 1 << 8
+        KINFO_RT_IFLIST   = KINFO_RT | 3
+
+        module Libc
+          extend ::FFI::Library
+
+          RTLD_LAZY   = 0x00000004
+          RTLD_GLOBAL = 0x00010000
+          RTLD_MEMBER = 0x00040000
+
+          @ffi_lib_flags = RTLD_LAZY | RTLD_GLOBAL | RTLD_MEMBER
+          ffi_lib 'libc.a(shr.o)'
+
+          attach_function :getkerninfo, %i[int pointer pointer int], :int
+          attach_function :inet_ntop, %i[int pointer pointer uint], :string
+        end
+
+        def self.read_load_averages
+          averages = ::FFI::MemoryPointer.new(:long_long, 3)
+          averages_size = ::FFI::MemoryPointer.new(:int, 1)
+          averages_size.write_int(averages.size)
+
+          return if Libc.getkerninfo(KINFO_READ | KINFO_GET_AVENRUN, averages, averages_size, 0).negative?
+
+          averages.read_array_of_long_long(3).map { |x| (x / 65_536.0) }
+        end
+
+        def self.read_interfaces
+          ksize = Libc.getkerninfo(KINFO_RT_IFLIST, nil, nil, 0)
+
+          log.debug('getkerninfo call was unsuccessful') if ksize.zero?
+
+          ksize_ptr = ::FFI::MemoryPointer.new(:int, ksize.size)
+          ksize_ptr.write_int(ksize)
+
+          result_ptr = ::FFI::MemoryPointer.new(:char, ksize)
+
+          res = Libc.getkerninfo(KINFO_RT_IFLIST, result_ptr, ksize_ptr, 0)
+          log.debug('getkerninfo call was unsuccessful') if res == -1
+
+          cursor = 0
+
+          interfaces = {}
+          while cursor < ksize_ptr.read_int
+            hdr = FFI::IfMsghdr.new(result_ptr + cursor)
+
+            case hdr[:ifm_type]
+            when FFI::RTM_IFINFO
+              link_addr = FFI::SockaddrDl.new(hdr.to_ptr + hdr.size)
+
+              interface_name = link_addr[:sdl_data].to_s[0, link_addr[:sdl_nlen]]
+              interfaces[interface_name] ||= {}
+
+            when FFI::RTM_NEWADDR
+              addresses = {}
+              addr_cursor = cursor + hdr.size
+              FFI::RTAX_LIST.each do |key|
+                xand = hdr[:ifm_addrs] & FFI::RTA_LIST[key]
+                next unless xand != 0
+
+                sockaddr = FFI::Sockaddr.new(result_ptr + addr_cursor)
+                addresses[key] = sockaddr
+                roundup_nr = roundup(sockaddr)
+                addr_cursor += roundup_nr
+              end
+
+              family = FFI::AF_UNSPEC
+
+              addresses.each_value do |addr|
+                if family != FFI::AF_UNSPEC &&
+                   addr[:sa_family] != FFI::AF_UNSPEC &&
+                   family != addr[:sa_family]
+                  family = FFI::AF_MAX
+                  break
+                end
+                family = addr[:sa_family]
+              end
+
+              if addresses[FFI::RTAX_NETMASK][:sa_len]
+                addresses[FFI::RTAX_NETMASK][:sa_family] = family
+                netmask = address_to_string(addresses[FFI::RTAX_NETMASK])
+              end
+
+              address = address_to_string(addresses[FFI::RTAX_IFA]) if addresses[FFI::RTAX_IFA][:sa_len]
+
+              if addresses[FFI::RTAX_NETMASK][:sa_len] && addresses[FFI::RTAX_IFA][:sa_len]
+                network = address_to_string(addresses[FFI::RTAX_IFA], addresses[FFI::RTAX_NETMASK])
+              end
+
+              bindings = family == FFI::AF_INET ? :bindings : :bindings6
+              interfaces[interface_name][bindings] ||= []
+              interfaces[interface_name][bindings] << {
+                netmask: netmask.read_string,
+                address: address.read_string,
+                network: network.read_string
+              }
+            else
+              log.debug("got an unknown RT_IFLIST message: #{hdr[:ifm_type]}")
+            end
+
+            cursor += hdr[:ifm_msglen]
+          end
+
+          interfaces
+        end
+
+        def self.roundup(sockaddr)
+          if sockaddr[:sa_len].positive?
+            1 + ((sockaddr[:sa_len] - 1) | (1.size - 1))
+          else
+            1.size
+          end
+        end
+
+        def self.address_to_string(sockaddr, mask = nil)
+          if sockaddr[:sa_family] == FFI::AF_INET
+            in_addr_ip = FFI::SockaddrIn.new(sockaddr.to_ptr)
+
+            if mask && sockaddr[:sa_family] == mask[:sa_family]
+              in_addr_mask = FFI::SockaddrIn.new(mask.to_ptr)
+              in_addr_ip[:sin_addr][:s_addr] &= in_addr_mask[:sin_addr][:s_addr]
+            end
+
+            buffer = ::FFI::MemoryPointer.new(:char, FFI::INET_ADDRSTRLEN)
+            Libc.inet_ntop(FFI::AF_INET, in_addr_ip[:sin_addr].to_ptr, buffer, 16)
+
+            buffer
+          elsif sockaddr[:sa_family] == FFI::AF_INET6
+            in_addr_ip = FFI::SockaddrIn6.new(sockaddr.to_ptr)
+            if mask && sockaddr[:sa_family] == mask[:sa_family]
+              in_addr_mask = FFI::SockaddrIn6.new(sockaddr.to_ptr)
+              16.times do |i|
+                in_addr_ip[:sin6_addr][:u6_addr8][i] &= in_addr_mask[:sin6_addr][:u6_addr8][i]
+              end
+            end
+
+            buffer = ::FFI::MemoryPointer.new(:char, FFI::INET6_ADDRSTRLEN)
+            Libc.inet_ntop(FFI::AF_INET6, in_addr_ip[:sin6_addr].to_ptr, buffer, 16)
+
+            buffer
+          end
+        end
+
+        def self.log
+          @log ||= Log.new(self)
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/aix/ffi/structs.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      module FFI
+        class SockaddrDl < ::FFI::Struct
+          layout :sdl_len, :uchar,
+                 :sdl_family, :uchar,
+                 :sdl_index, :ushort,
+                 :sdl_type, :uchar,
+                 :sdl_nlen, :uchar,
+                 :sdl_alen, :uchar,
+                 :sdl_slen, :uchar,
+                 :sdl_data, [:char, 120]
+        end
+
+        class IfMsghdr < ::FFI::Struct
+          layout :ifm_msglen, :ushort,
+                 :ifm_version, :uchar,
+                 :ifm_type, :uchar,
+                 :ifm_addrs, :int,
+                 :ifm_flags, :int,
+                 :ifm_index, :ushort,
+                 :ifm_addrlen, :uchar
+        end
+
+        class Sockaddr < ::FFI::Struct
+          layout :sa_len, :uchar,
+                 :sa_family, :uchar,
+                 :sa_data, [:char, 14]
+        end
+
+        class InAddr < ::FFI::Struct
+          layout :s_addr, :uint
+        end
+
+        class In6Addr < ::FFI::Struct
+          layout :u6_addr8, [:uchar, 16]
+        end
+
+        class SockaddrIn < ::FFI::Struct
+          layout :sin_len, :uchar,
+                 :sin_family, :uchar,
+                 :sin_port, :ushort,
+                 :sin_addr, InAddr,
+                 :sin_zero, [:uchar, 8]
+        end
+
+        class SockaddrIn6 < ::FFI::Struct
+          layout :sin6_len, :uchar,
+                 :sin6_family, :uchar,
+                 :sin6_port, :ushort,
+                 :sin6_flowinfo, :uint,
+                 :sin6_addr, In6Addr,
+                 :sin6_scope_id, :uint
+        end
+
+        class SockaddrStorage < ::FFI::Struct
+          layout :ss_len, :uchar,
+                 :ss_family, :uchar,
+                 :ss_pad, [:char, 6],
+                 :ss_align, :long_long,
+                 :ss_pad2, [:char, 1264]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/aix/filesystems.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Filesystems < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { read_vtf_file(fact_name) }
+          end
+
+          def read_vtf_file(fact_name)
+            file_content = Facter::Util::FileHelper.safe_readlines('/etc/vfs')
+            return if file_content.empty?
+
+            file_content = file_content.map do |line|
+              next if /#|%/.match?(line) # skip lines that are comments or defaultvfs line
+
+              line.split(' ').first
+            end
+
+            @fact_list[:file_systems] = file_content.compact.sort.join(',')
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/aix/hardware.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Hardware < BaseResolver
+      # :hardware
+      init_resolver
+
+      class << self
+        private
+
+        def post_resolve(fact_name, _options)
+          @fact_list.fetch(fact_name) { read_hardware(fact_name) }
+        end
+
+        def read_hardware(fact_name)
+          require_relative '../../../facter/util/aix/odm_query'
+          odmquery = Facter::Util::Aix::ODMQuery.new
+          odmquery
+            .equals('name', 'sys0')
+            .equals('attribute', 'modelname')
+
+          result = odmquery.execute
+
+          return unless result
+
+          result.each_line do |line|
+            if line.include?('value')
+              @fact_list[:hardware] = line.split('=')[1].strip.delete('\"')
+              break
+            end
+          end
+
+          @fact_list[fact_name]
+        end
+      end
+    end
+  end
+end

data/lib/facter/resolvers/aix/load_averages.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class LoadAverages < BaseResolver
+        init_resolver
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @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] = {}.tap do |h|
+              h['1m'], h['5m'], h['15m'] = FfiHelper.read_load_averages
+            end
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Memory < BaseResolver
+        init_resolver
+        # :hardware
+
+        class << self
+          private
+
+          def post_resolve(fact_name, _options)
+            @fact_list.fetch(fact_name) { execute_svmon(fact_name) }
+          end
+
+          def execute_svmon(fact_name)
+            result = Facter::Core::Execution.execute('svmon', logger: log)
+            return if result.empty?
+
+            pagesize = call_pagesize.to_i
+            return if pagesize.zero?
+
+            @fact_list[:system] = @fact_list[:swap] = {}
+
+            result.each_line do |line|
+              @fact_list[:system] = populate_system(line, pagesize) if line.include?('memory')
+              @fact_list[:swap] = populate_swap(line, pagesize) if /pg\sspace/.match?(line)
+            end
+
+            @fact_list[fact_name]
+          end
+
+          def call_pagesize
+            Facter::Core::Execution.execute('pagesize', logger: log).strip
+          end
+
+          def populate_system(content, pagesize)
+            content = content.split(' ')
+
+            total = content[1].to_i * pagesize
+            used = content[2].to_i * pagesize
+
+            { available_bytes: content[3].to_i * pagesize,
+              total_bytes: total,
+              used_bytes: used,
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used, total) }
+          end
+
+          def populate_swap(content, pagesize)
+            content = content.split(' ')
+
+            total = content[2].to_i * pagesize
+            used = content[3].to_i * pagesize
+
+            { available_bytes: total - used,
+              total_bytes: total,
+              used_bytes: used,
+              capacity: Facter::Util::Resolvers::FilesystemHelper.compute_capacity(used, total) }
+          end
+        end
+      end
+    end
+  end
+end