facter 4.0.31 → 4.0.36

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/sshalgorithmkey.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class Sshalgorithmkey
+      FACT_NAME = 'ssh.*key'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result.each { |ssh| facts << Facter::ResolvedFact.new("ssh#{ssh.name.to_sym}key", ssh.key, :legacy) }
+        facts
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class SshfpAlgorithm
+      FACT_NAME = 'sshfp_.*'
+      TYPE = :legacy
+
+      def call_the_resolver
+        facts = []
+        result = Facter::Resolvers::SshResolver.resolve(:ssh)
+        result.each do |ssh|
+          facts << Facter::ResolvedFact.new("sshfp_#{ssh.name.to_sym}",
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
+        end
+        facts
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class Virtual
+      FACT_NAME = 'virtual'
+
+      def initialize
+        @log = Facter::Log.new(self)
+      end
+
+      def call_the_resolver
+        @log.debug('Solaris Virtual Resolver')
+
+        fact_value = check_ldom || check_zone || check_xen || check_other_facts || 'physical'
+
+        @log.debug("Fact value is: #{fact_value}")
+
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+
+      def check_ldom
+        @log.debug('Checking LDoms')
+        return unless Facter::Resolvers::Solaris::Ldom.resolve(:role_control) == 'false'
+
+        Facter::Resolvers::Solaris::Ldom.resolve(:role_impl)
+      end
+
+      def check_zone
+        @log.debug('Checking LDoms')
+        zone_name = Facter::Resolvers::Solaris::ZoneName.resolve(:current_zone_name)
+
+        return if zone_name == 'global'
+
+        'zone'
+      end
+
+      def check_xen
+        @log.debug('Checking XEN')
+        Facter::Resolvers::Xen.resolve(:vm)
+      end
+
+      def check_other_facts
+        isa = Facter::Resolvers::Uname.resolve(:processor)
+        klass = isa == 'sparc' ? 'DmiSparc' : 'Dmi'
+
+        product_name = Facter::Resolvers::Solaris.const_get(klass).resolve(:product_name)
+        bios_vendor = Facter::Resolvers::Solaris.const_get(klass).resolve(:bios_vendor)
+
+        return 'kvm' if bios_vendor&.include?('Amazon EC2')
+
+        return unless product_name
+
+        Facter::FactsUtils::HYPERVISORS_HASH.each { |key, value| return value if product_name.include?(key) }
+
+        nil
+      end
+    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.to_s, :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

data/lib/facter/facts/windows/dhcp_servers.rb

@@ -14,10 +14,10 @@ module Facts
       private
 
       def construct_addresses_hash
-        interfaces = Facter::Resolvers::Networking.resolve(:interfaces)
+        interfaces = Facter::Resolvers::Windows::Networking.resolve(:interfaces)
         return unless interfaces
 
-        servers = { system: Facter::Resolvers::Networking.resolve(:dhcp) }
+        servers = { system: Facter::Resolvers::Windows::Networking.resolve(:dhcp) }
         interfaces&.each { |interface_name, info| servers[interface_name] = info[:dhcp] if info[:dhcp] }
         servers
       end

data/lib/facter/facts/windows/ec2_metadata.rb

@@ -6,14 +6,16 @@ module Facts
       FACT_NAME = 'ec2_metadata'
 
       def call_the_resolver
-        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws?
+        return Facter::ResolvedFact.new(FACT_NAME, nil) unless aws_hypervisors?
 
         fact_value = Facter::Resolvers::Ec2.resolve(:metadata)
 
-        Facter::ResolvedFact.new(FACT_NAME, fact_value.empty? ? nil : fact_value)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value&.empty? ? nil : fact_value)
       end
 
-      def aws?
+      private
+
+      def aws_hypervisors?
         virtual = Facter::Resolvers::Virtualization.resolve(:virtual)
 
         virtual == 'kvm' || virtual =~ /xen/