facter 4.0.23

data/lib/framework/utils/utils.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Facter
+  module Utils
+    # Sort nested hash.
+    def self.sort_hash_by_key(hash, recursive = true, &block)
+      hash.keys.sort(&block).each_with_object({}) do |key, seed|
+        seed[key] = hash[key]
+        seed[key] = sort_hash_by_key(seed[key], true, &block) if recursive && seed[key].is_a?(Hash)
+
+        seed
+      end
+    end
+
+    def self.deep_copy(obj)
+      Marshal.load(Marshal.dump(obj))
+    end
+
+    def self.split_user_query(user_query)
+      queries = user_query.split('.')
+      queries.map! { |query| query =~ /^[0-9]+$/ ? query.to_i : query }
+    end
+
+    def self.deep_stringify_keys(object)
+      case object
+      when Hash
+        object.each_with_object({}) do |(key, value), result|
+          result[key.to_s] = deep_stringify_keys(value)
+        end
+      when Array
+        object.map { |e| deep_stringify_keys(e) }
+      else
+        object
+      end
+    end
+  end
+end

data/lib/models/fact_collection.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Facter
+  class FactCollection < Hash
+    def initialize
+      super
+    end
+
+    def build_fact_collection!(facts)
+      facts.each do |fact|
+        next if %i[core legacy].include?(fact.type) && fact.value.nil?
+
+        bury_fact(fact)
+      end
+
+      self
+    end
+
+    def value(*keys)
+      keys.reduce(self) do |memo, key|
+        memo.fetch(key.to_s)
+      end
+    end
+
+    def bury(*args)
+      raise ArgumentError, '2 or more arguments required' if args.count < 2
+
+      if args.count == 2
+        self[args[0]] = args[1]
+      else
+        arg = args.shift
+        self[arg] = FactCollection.new unless self[arg]
+        self[arg].bury(*args) unless args.empty?
+      end
+
+      self
+    end
+
+    private
+
+    def bury_fact(fact)
+      bury(*fact.name.split('.') + fact.filter_tokens << fact.value)
+    end
+  end
+end

data/lib/models/loaded_fact.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Facter
+  class LoadedFact
+    attr_reader :name, :klass, :type
+
+    def initialize(name, klass, type = nil)
+      @name = name
+      @klass = klass
+      @type = type.nil? ? :core : type
+    end
+  end
+end

data/lib/models/resolved_fact.rb

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

data/lib/models/searched_fact.rb

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

data/lib/resolvers/agent_resolver.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Agent < BaseResolver
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_agent_version }
+        end
+
+        def read_agent_version
+          version_file = ::File.join(ROOT_DIR, 'lib/puppet/VERSION')
+          @fact_list[:aio_agent_version] = ::File.read(version_file)
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/architecture_resolver.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Architecture < BaseResolver
+      # :architecture
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_architecture(fact_name) }
+        end
+
+        def read_architecture(fact_name)
+          require_relative 'utils/odm_query'
+          odmquery = ODMQuery.new
+          odmquery
+            .equals('name', 'proc0')
+            .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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'ffi'
+
+module Facter
+  module Aix
+    module FfiHelper
+      KINFO_GET_AVENRUN = 1
+      KINFO_READ        = 8 << 8
+
+      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
+      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).round(5) }
+      end
+    end
+  end
+end

data/lib/resolvers/aix/filesystem_resolver.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Filesystem < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_vtf_file(fact_name) }
+          end
+
+          def read_vtf_file(fact_name)
+            file_content = Util::FileHelper.safe_readlines('/etc/vfs')
+            return if file_content.empty?
+
+            file_content = file_content.map do |line|
+              next if 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/resolvers/aix/hardware_resolver.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    class Hardware < BaseResolver
+      # :hardware
+      @semaphore = Mutex.new
+      @fact_list ||= {}
+      class << self
+        private
+
+        def post_resolve(fact_name)
+          @fact_list.fetch(fact_name) { read_hardware(fact_name) }
+        end
+
+        def read_hardware(fact_name)
+          require_relative 'utils/odm_query'
+          odmquery = Facter::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/resolvers/aix/load_averages_resolver.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      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] = {}.tap do |h|
+              h['1m'], h['5m'], h['15m'] = Facter::Aix::FfiHelper.read_load_averages
+            end
+
+            @fact_list[fact_name]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/mountpoints.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Mountpoints < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        BLOCK_SIZE = 512
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_mount(fact_name) }
+          end
+
+          def read_mount(fact_name)
+            @fact_list[:mountpoints] = {}
+            output = Facter::Core::Execution.execute('mount', logger: log)
+            output.split("\n").map do |line|
+              next if line =~ /node|---|procfs|ahafs/
+
+              elem = line.split("\s")
+
+              @fact_list[:mountpoints][elem[1]] = { device: elem[0], filesystem: elem[2],
+                                                    options: elem.last.split(',') }
+            end
+
+            retrieve_sizes_for_mounts
+            @fact_list[fact_name]
+          end
+
+          def retrieve_sizes_for_mounts
+            output = Facter::Core::Execution.execute('df -P', logger: log)
+            output.split("\n").map do |line|
+              next if line =~ /Filesystem|-\s+-\s+-/
+
+              mount_info = line.split("\s")
+              mount_info[3] = translate_to_bytes(mount_info[3])
+              mount_info[2] = translate_to_bytes(mount_info[2])
+              mount_info[1] = translate_to_bytes(mount_info[1])
+              compute_sizes(mount_info)
+            end
+          end
+
+          def translate_to_bytes(strin_size)
+            strin_size.to_i * BLOCK_SIZE
+          end
+
+          def compute_sizes(info)
+            available_bytes = info[3]
+            used_bytes = info[2]
+            size_bytes = info[1]
+            @fact_list[:mountpoints][info.last].merge!(
+              capacity: FilesystemHelper.compute_capacity(used_bytes, size_bytes),
+              available_bytes: available_bytes,
+              used_bytes: used_bytes,
+              size_bytes: size_bytes,
+              available: FactsUtils::UnitConverter.bytes_to_human_readable(available_bytes),
+              used: FactsUtils::UnitConverter.bytes_to_human_readable(used_bytes),
+              size: FactsUtils::UnitConverter.bytes_to_human_readable(size_bytes)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/resolvers/aix/networking_resolver.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Networking < BaseResolver
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @fact_list.fetch(fact_name) { read_netstat(fact_name) }
+          end
+
+          def read_netstat(fact_name)
+            output = Facter::Core::Execution.execute('netstat -rn', logger: log)
+            output = output.split("\n").select { |line| (line =~ /\s\s[0-9]+.[0-9]+.[0-9]+.[0-9]+|\s\s.*:[0-9a-f]+/) }
+            get_primary_interface_info(output)
+
+            @fact_list[fact_name]
+          end
+
+          def get_primary_interface_info(output)
+            primary_interface_info = output.find { |line| line =~ /=>/ }.split(' ')
+            @fact_list[:primary] = primary_interface_info[5]
+            @fact_list[:ip] = primary_interface_info[1]
+          end
+        end
+      end
+    end
+  end
+end