facter 4.0.31 → 4.0.36

data/lib/facter/facts/solaris/dmi/product/name.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      module Product
+        class Name
+          FACT_NAME = 'dmi.product.name'
+          ALIASES = 'productname'
+
+          def call_the_resolver
+            fact_value = if isa == 'i386'
+                           Facter::Resolvers::Solaris::Dmi.resolve(:product_name)
+                         elsif isa == 'sparc'
+                           Facter::Resolvers::Solaris::DmiSparc.resolve(:product_name)
+                         end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+
+          def isa
+            Facter::Resolvers::Uname.resolve(:processor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/dmi/product/serial_number.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      module Product
+        class SerialNumber
+          FACT_NAME = 'dmi.product.serial_number'
+          ALIASES = 'serialnumber'
+
+          def call_the_resolver
+            fact_value = if isa == 'i386'
+                           Facter::Resolvers::Solaris::Dmi.resolve(:serial_number)
+                         elsif isa == 'sparc'
+                           Facter::Resolvers::Solaris::DmiSparc.resolve(:serial_number)
+                         end
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+
+          def isa
+            Facter::Resolvers::Uname.resolve(:processor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/dmi/product/uuid.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Dmi
+      module Product
+        class Uuid
+          FACT_NAME = 'dmi.product.uuid'
+          ALIASES = 'uuid'
+
+          def call_the_resolver
+            fact_value = nil
+            fact_value = Facter::Resolvers::Solaris::Dmi.resolve(:product_uuid) if isa == 'i386'
+            [Facter::ResolvedFact.new(FACT_NAME, fact_value), Facter::ResolvedFact.new(ALIASES, fact_value, :legacy)]
+          end
+
+          def isa
+            Facter::Resolvers::Uname.resolve(:processor)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/hypervisors/ldom.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Hypervisors
+      class Ldom
+        FACT_NAME = 'hypervisors.ldom'
+
+        def initialize
+          @log = Facter::Log.new(self)
+        end
+
+        def call_the_resolver
+          fact_value = %i[
+            chassis_serial control_domain domain_name
+            domain_uuid role_control role_io role_root role_service
+          ].map! { |key| [key, Facter::Resolvers::Solaris::Ldom.resolve(key)] }.to_h
+
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/solaris/hypervisors/zone.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Hypervisors
+      class Zone
+        FACT_NAME = 'hypervisors.zone'
+
+        def initialize
+          @log = Facter::Log.new(self)
+        end
+
+        def call_the_resolver
+          fact_value = current_zone
+
+          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        end
+
+        def current_zone
+          current_zone_name = Facter::Resolvers::Solaris::ZoneName.resolve(:current_zone_name)
+          return unless current_zone_name
+
+          zones = Facter::Resolvers::Solaris::Zone.resolve(:zone)
+          return nil unless zones
+
+          current_zone = zones.find { |r| r[:name] == current_zone_name }
+
+          {
+            brand: current_zone[:brand],
+            id: current_zone[:id],
+            ip_type: current_zone[:iptype],
+            name: current_zone[:name],
+            uuid: current_zone[:uuid]
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class IsVirtual
+      FACT_NAME = 'is_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, check_if_virtual(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
+
+      def check_if_virtual(found_vm)
+        Facter::FactsUtils::PHYSICAL_HYPERVISORS.count(found_vm).zero?
+      end
+    end
+  end
+end

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

@@ -8,7 +8,7 @@ module Facts
       def call_the_resolver
         full_version = Facter::Resolvers::Uname.resolve(:kernelversion)
         versions_split = full_version.split('.')
-        major_version = versions_split.length > 1 ? versions_split[0] + '.' + versions_split[1] : versions_split[0]
+        major_version = versions_split.length > 2 ? versions_split[0] + '.' + versions_split[1] : versions_split[0]
         Facter::ResolvedFact.new(FACT_NAME, major_version)
       end
     end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class Ldom
+      FACT_NAME = 'ldom'
+
+      def initialize
+        @log = Facter::Log.new(self)
+      end
+
+      def call_the_resolver
+        fact_value = {
+          domainchassis: resolve(:chassis_serial),
+          domaincontrol: resolve(:control_domain),
+          domainname: resolve(:domain_name),
+          domainrole: {
+            control: resolve(:role_control),
+            impl: resolve(:role_impl),
+            io: resolve(:role_io),
+            root: resolve(:role_root),
+            service: resolve(:role_service)
+          },
+          domainuuid: resolve(:domain_uuid)
+        }
+
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+
+      def resolve(key)
+        Facter::Resolvers::Solaris::Ldom.resolve(key)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    class LoadAverages
+      FACT_NAME = 'load_averages'
+
+      def call_the_resolver
+        fact_value = Facter::Resolvers::LoadAverages.resolve(:load_averages)
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Facts
+  module Solaris
+    module Memory
+      module Swap
+        class Available
+          FACT_NAME = 'memory.swap.available'
+          ALIASES = 'swapfree'
+
+          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[: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/swap/available_bytes.rb

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

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