facter 4.0.35 → 4.0.36

data/lib/facter/facts/linux/gce.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    class Gce
+      FACT_NAME = 'gce'
+
+      def call_the_resolver
+        bios_vendor = Facter::Resolvers::Linux::DmiBios.resolve(:bios_vendor)
+
+        fact_value = bios_vendor&.include?('Google') ? Facter::Resolvers::Gce.resolve(:metadata) : nil
+        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+      end
+    end
+  end
+end

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

@@ -5,8 +5,6 @@ module Facts
     class IsVirtual
       FACT_NAME = 'is_virtual'
 
-      PHYSICAL_HYPERVISORS = %w[physical xen0 vmware_server vmware_workstation openvzhn vserver_host].freeze
-
       def call_the_resolver # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         fact_value = check_docker_lxc || check_gce || retrieve_from_virt_what || check_vmware
         fact_value ||= check_open_vz || check_vserver || check_xen || check_other_facts || check_lspci || 'physical'
@@ -59,7 +57,7 @@ module Facts
       end
 
       def check_if_virtual(found_vm)
-        PHYSICAL_HYPERVISORS.count(found_vm).zero?
+        Facter::FactsUtils::PHYSICAL_HYPERVISORS.count(found_vm).zero?
       end
     end
   end

data/lib/facter/facts/linux/networking/scope6.rb

@@ -5,11 +5,13 @@ module Facts
     module Networking
       class Scope6
         FACT_NAME = 'networking.scope6'
+        ALIASES = 'scope6'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::NetworkingLinux.resolve(:scope6)
 
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+           Facter::ResolvedFact.new('scope6', fact_value, :legacy)]
         end
       end
     end

data/lib/facter/facts/linux/processors/speed.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    module Processors
+      class Speed
+        FACT_NAME = 'processors.speed'
+
+        def call_the_resolver
+          fact_value = Facter::Resolvers::Linux::Processors.resolve(:speed)
+          speed = Facter::FactsUtils::UnitConverter.hertz_to_human_readable(fact_value)
+          Facter::ResolvedFact.new(FACT_NAME, speed)
+        end
+      end
+    end
+  end
+end

data/lib/facter/facts/linux/scope6_interfaces.rb

@@ -9,14 +9,13 @@ module Facts
       def call_the_resolver
         resolved_facts = []
         interfaces = Facter::Resolvers::NetworkingLinux.resolve(:interfaces)
-        primary_scope6 = Facter::Resolvers::NetworkingLinux.resolve(:scope6)
 
         interfaces&.each do |interface_name, info|
           if info[:scope6]
             resolved_facts << Facter::ResolvedFact.new("scope6_#{interface_name}", info[:scope6], :legacy)
           end
         end
-        resolved_facts << Facter::ResolvedFact.new('scope6', primary_scope6, :legacy) if primary_scope6
+
         resolved_facts
       end
     end

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

@@ -11,7 +11,7 @@ module 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)
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
         end
         facts
       end

data/lib/facter/facts/linux/xen.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Facts
+  module Linux
+    class Xen
+      FACT_NAME = 'xen'
+      ALIASES = 'xendomains'
+
+      def call_the_resolver
+        xen_type = check_virt_what || check_xen
+        return Facter::ResolvedFact.new(FACT_NAME, nil) if !xen_type || xen_type != 'xen0'
+
+        domains = Facter::Resolvers::Xen.resolve(:domains) || []
+
+        [Facter::ResolvedFact.new(FACT_NAME, { domains: domains }),
+         Facter::ResolvedFact.new(ALIASES, domains.entries.join(','), :legacy)]
+      end
+
+      def check_virt_what
+        Facter::Resolvers::VirtWhat.resolve(:vm)
+      end
+
+      def check_xen
+        Facter::Resolvers::Xen.resolve(:vm)
+      end
+    end
+  end
+end

data/lib/facter/facts/macosx/networking/scope6.rb

@@ -5,11 +5,13 @@ module Facts
     module Networking
       class Scope6
         FACT_NAME = 'networking.scope6'
+        ALIASES = 'scope6'
 
         def call_the_resolver
           fact_value = Facter::Resolvers::Networking.resolve(:scope6)
 
-          Facter::ResolvedFact.new(FACT_NAME, fact_value)
+          [Facter::ResolvedFact.new(FACT_NAME, fact_value),
+           Facter::ResolvedFact.new('scope6', fact_value, :legacy)]
         end
       end
     end

data/lib/facter/facts/macosx/scope6_interfaces.rb

@@ -9,14 +9,12 @@ module Facts
       def call_the_resolver
         resolved_facts = []
         interfaces = Facter::Resolvers::Networking.resolve(:interfaces)
-        primary_scope6 = Facter::Resolvers::Networking.resolve(:scope6)
 
         interfaces&.each do |interface_name, info|
           if info[:scope6]
             resolved_facts << Facter::ResolvedFact.new("scope6_#{interface_name}", info[:scope6], :legacy)
           end
         end
-        resolved_facts << Facter::ResolvedFact.new('scope6', primary_scope6, :legacy) if primary_scope6
         resolved_facts
       end
     end

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

@@ -11,7 +11,7 @@ module 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)
+                                            "#{ssh.fingerprint.sha1}\n#{ssh.fingerprint.sha256}", :legacy)
         end
         facts
       end

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

@@ -4,10 +4,29 @@ module Facts
   module Solaris
     class Disks
       FACT_NAME = 'disks'
+      ALIASES = %w[blockdevices blockdevice_.*_size blockdevice_.*_vendor'].freeze
 
       def call_the_resolver
-        fact_value = Facter::Resolvers::Solaris::Disks.resolve(:disks)
-        Facter::ResolvedFact.new(FACT_NAME, fact_value)
+        facts = []
+        disks = Facter::Resolvers::Solaris::Disks.resolve(:disks)
+
+        return Facter::ResolvedFact.new(FACT_NAME, nil) if disks.nil? || disks.empty?
+
+        blockdevices = disks.keys.join(',')
+        facts.push(Facter::ResolvedFact.new(FACT_NAME, disks))
+        facts.push(Facter::ResolvedFact.new('blockdevices', blockdevices, :legacy))
+        add_legacy_facts(disks, facts)
+
+        facts
+      end
+
+      private
+
+      def add_legacy_facts(disks, facts)
+        disks.each do |disk_name, disk_info|
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_size", disk_info[:size_bytes].to_s, :legacy))
+          facts.push(Facter::ResolvedFact.new("blockdevice_#{disk_name}_vendor", disk_info[:vendor], :legacy))
+        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/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