facter 4.0.30 → 4.0.35

data/lib/facter/facts/solaris/memory/swap/capacity.rb

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

data/lib/facter/facts/solaris/memory/swap/total.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class Total
+          FACT_NAME = 'memory.swap.total'
+          ALIASES = 'swapsize'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::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

data/lib/facter/facts/solaris/memory/swap/total_bytes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class TotalBytes
+          FACT_NAME = 'memory.swap.total_bytes'
+          ALIASES = 'swapsize_mb'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::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

data/lib/facter/facts/solaris/memory/swap/used.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class Used
+          FACT_NAME = 'memory.swap.used'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::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

data/lib/facter/facts/solaris/memory/swap/used_bytes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class UsedBytes
+          FACT_NAME = 'memory.swap.used_bytes'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::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

data/lib/facter/facts/solaris/memory/system/available.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class Available
+          FACT_NAME = 'memory.system.available'
+          ALIASES = 'memoryfree'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::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

data/lib/facter/facts/solaris/memory/system/available_bytes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class AvailableBytes
+          FACT_NAME = 'memory.system.available_bytes'
+          ALIASES = 'memoryfree_mb'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::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

data/lib/facter/facts/solaris/memory/system/capacity.rb

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

data/lib/facter/facts/solaris/memory/system/total.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class Total
+          FACT_NAME = 'memory.system.total'
+          ALIASES = 'memorysize'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::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

data/lib/facter/facts/solaris/memory/system/total_bytes.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class TotalBytes
+          FACT_NAME = 'memory.system.total_bytes'
+          ALIASES = 'memorysize_mb'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::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

data/lib/facter/facts/solaris/memory/system/used.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class Used
+          FACT_NAME = 'memory.system.used'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::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

data/lib/facter/facts/solaris/memory/system/used_bytes.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module System
+        class UsedBytes
+          FACT_NAME = 'memory.system.used_bytes'
+
+          def call_the_resolver
+            fact_value = Facter::Resolvers::Solaris::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

data/lib/facter/facts/solaris/mountpoints.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'mountpoints'
 
       def call_the_resolver
-        mountpoints = Facter::Resolvers::Linux::Mountpoints.resolve(FACT_NAME.to_sym)
+        mountpoints = Facter::Resolvers::Mountpoints.resolve(FACT_NAME.to_sym)
         return Facter::ResolvedFact.new(FACT_NAME, nil) unless mountpoints
 
         fact = {}

data/lib/facter/facts/solaris/os/release.rb

@@ -8,9 +8,9 @@ module Facts
         ALIASES = %w[operatingsystemmajrelease operatingsystemrelease].freeze
 
         def call_the_resolver
-          full_value = Facter::Resolvers::SolarisRelease.resolve(:full)
-          major_value = Facter::Resolvers::SolarisRelease.resolve(:major)
-          minor_value = Facter::Resolvers::SolarisRelease.resolve(:minor)
+          full_value = Facter::Resolvers::Solaris::OsRelease.resolve(:full)
+          major_value = Facter::Resolvers::Solaris::OsRelease.resolve(:major)
+          minor_value = Facter::Resolvers::Solaris::OsRelease.resolve(:minor)
 
           [Facter::ResolvedFact.new(FACT_NAME, full: full_value, major: major_value, minor: minor_value),
            Facter::ResolvedFact.new(ALIASES.first, major_value, :legacy),

data/lib/facter/facts/solaris/ssh.rb

@@ -6,20 +6,30 @@ module Facts
       FACT_NAME = 'ssh'
 
       def call_the_resolver
-        result = Facter::Resolvers::SshResolver.resolve(:ssh)
-        ssh_facts = {}
-        result.each { |ssh| ssh_facts.merge!(create_ssh_fact(ssh)) }
-        Facter::ResolvedFact.new(FACT_NAME, ssh_facts)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
 
       private
 
+      def fact_value
+        resolver_data.map { |el| create_ssh_fact(el) }.inject(:merge)
+      end
+
+      def resolver_data
+        Facter::Resolvers::SshResolver.resolve(:ssh)
+      end
+
       def create_ssh_fact(ssh)
-        { ssh.name.to_sym =>
-              { fingerprints: { sha1: ssh.fingerprint.sha1,
-                                sha256: ssh.fingerprint.sha256 },
-                key: ssh.key,
-                type: ssh.type } }
+        return {} unless ssh
+
+        { ssh.name.to_sym => {
+          fingerprints: {
+            sha1: ssh.fingerprint.sha1,
+            sha256: ssh.fingerprint.sha256
+          },
+          key: ssh.key,
+          type: ssh.type
+        } }
       end
     end
   end

data/lib/facter/facts/solaris/zfs_featurenumbers.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'zfs_featurenumbers'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::ZFS.resolve(:zfs_featurenumbers)
+        fact_value = Facter::Resolvers::ZFS.resolve(:zfs_featurenumbers)
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
     end

data/lib/facter/facts/solaris/zfs_version.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'zfs_version'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::ZFS.resolve(:zfs_version)
+        fact_value = Facter::Resolvers::ZFS.resolve(:zfs_version)
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
     end

data/lib/facter/facts/solaris/zones.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class Zones
+      FACT_NAME = 'solaris_zones.zones'
+      ALIASES = %w[
+        zone_.*_brand
+        zone_.*_iptype
+        zone_.*_name
+        zone_.*_uuid
+        zone_.*_id
+        zone_.*_path
+        zone_.*_status
+        zones
+      ].freeze
+
+      def call_the_resolver
+        resolved_facts = []
+        zones = {}
+
+        results = Facter::Resolvers::Solaris::Zone.resolve(:zone)
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless results
+
+        results&.each do |result|
+          zones.merge!(parse_result(result))
+          resolved_facts << create_legacy_zone_facts(result)
+        end
+
+        resolved_facts << Facter::ResolvedFact.new('solaris_zones.zones', zones)
+        resolved_facts << Facter::ResolvedFact.new('zones', results.count, :legacy)
+
+        resolved_facts.flatten
+      end
+
+      private
+
+      def parse_result(result)
+        {
+          result[:name].to_sym => {
+            brand: result[:brand],
+            id: result[:id],
+            ip_type: result[:iptype],
+            path: result[:path],
+            status: result[:status]
+          }
+        }
+      end
+
+      def create_legacy_zone_facts(zone)
+        legacy_facts = []
+        %w[brand iptype name uuid id path status].each do |key|
+          legacy_facts << Facter::ResolvedFact.new("zone_#{zone[:name]}_#{key}", zone[key.to_sym], :legacy)
+        end
+
+        legacy_facts
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/zpool_featureflags.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'zpool_featureflags'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::ZPool.resolve(:zpool_featureflags)
+        fact_value = Facter::Resolvers::Zpool.resolve(:zpool_featureflags)
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
     end

data/lib/facter/facts/solaris/zpool_featurenumbers.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'zpool_featurenumbers'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::ZPool.resolve(:zpool_featurenumbers)
+        fact_value = Facter::Resolvers::Zpool.resolve(:zpool_featurenumbers)
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
     end

data/lib/facter/facts/solaris/zpool_version.rb

@@ -6,7 +6,7 @@ module Facts
       FACT_NAME = 'zpool_version'
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::ZPool.resolve(:zpool_version)
+        fact_value = Facter::Resolvers::Zpool.resolve(:zpool_version)
         Facter::ResolvedFact.new(FACT_NAME, fact_value)
       end
     end