(FACT-2230) Add Aix memory facts

lib/facter/facts/aix/memory/swap/available.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module Swap
+        class Available
+          FACT_NAME = 'memory.swap.available'
+          ALIASES = 'swapfree'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:swap)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
+            end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/swap/available_bytes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module Swap
+        class AvailableBytes
+          FACT_NAME = 'memory.swap.available_bytes'
+          ALIASES = 'swapfree_mb'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:swap)
+            fact_value = fact_value[:available_bytes] if fact_value
+
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/swap/capacity.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module Swap
+        class Capacity
+          FACT_NAME = 'memory.swap.capacity'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:swap)
+            fact_value = fact_value[:capacity] if fact_value
+
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/swap/total.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module Swap
+        class Total
+          FACT_NAME = 'memory.swap.total'
+          ALIASES = 'swapsize'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:swap)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
+            end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/swap/total_bytes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module Swap
+        class TotalBytes
+          FACT_NAME = 'memory.swap.total_bytes'
+          ALIASES = 'swapsize_mb'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:swap)
+            fact_value = fact_value[:total_bytes] if fact_value
+
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/swap/used.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module Swap
+        class Used
+          FACT_NAME = 'memory.swap.used'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:swap)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
+            end
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/swap/used_bytes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module Swap
+        class UsedBytes
+          FACT_NAME = 'memory.swap.used_bytes'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:swap)
+            fact_value = fact_value[:used_bytes] if fact_value
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/system/available.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module System
+        class Available
+          FACT_NAME = 'memory.system.available'
+          ALIASES = 'memoryfree'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:system)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:available_bytes])
+            end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/system/available_bytes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module System
+        class AvailableBytes
+          FACT_NAME = 'memory.system.available_bytes'
+          ALIASES = 'memoryfree_mb'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:system)
+            fact_value = fact_value[:available_bytes] if fact_value
+
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/system/capacity.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module System
+        class Capacity
+          FACT_NAME = 'memory.system.capacity'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:system)
+            fact_value = fact_value[:capacity] if fact_value
+
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/system/total.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module System
+        class Total
+          FACT_NAME = 'memory.system.total'
+          ALIASES = 'memorysize'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:system)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:total_bytes])
+            end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/system/total_bytes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module System
+        class TotalBytes
+          FACT_NAME = 'memory.system.total_bytes'
+          ALIASES = 'memorysize_mb'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:system)
+            fact_value = fact_value[:total_bytes] if fact_value
+
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+             Facter::ResolvedFact.new(ALIASES, Facter::FactsUtils::UnitConverter.bytes_to_mb(fact_value), :legacy)]
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/system/used.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module System
+        class Used
+          FACT_NAME = 'memory.system.used'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:system)
+            if fact_value
+              fact_value = Facter::FactsUtils::UnitConverter.bytes_to_human_readable(fact_value[:used_bytes])
+            end
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/facts/aix/memory/system/used_bytes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facts
+  module Aix
+    module Memory
+      module System
+        class UsedBytes
+          FACT_NAME = 'memory.system.used_bytes'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Aix::Memory.resolve(:system)
+            fact_value = fact_value[:used_bytes] if fact_value
+            Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          end
+        end
+      end
+    end
+  end
+end

lib/facter/resolvers/aix/memory.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Facter
+  module Resolvers
+    module Aix
+      class Memory < BaseResolver
+        # :hardware
+        @semaphore = Mutex.new
+        @fact_list ||= {}
+        class << self
+          private
+
+          def post_resolve(fact_name)
+            @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?
+
+            @fact_list[:system] = @fact_list[:swap] = {}
+
+            pagesize = call_pagesize.to_i
+            return if pagesize.zero?
+
+            result.each_line do |line|
+              @fact_list[:system] = populate_system(line, pagesize) if line.include?('memory')
+              @fact_list[:swap] = populate_swap(line, pagesize) if line =~ /pg\sspace/
+            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: 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: FilesystemHelper.compute_capacity(used, total) }
+          end
+        end
+      end
+    end
+  end
+end